Introduzione

Aspose.3D FOSS per TypeScript (@aspose/3d) è una libreria open-source, con licenza MIT, per formati di file 3D progettata principalmente per Node.js. Gli sviluppatori che creano visualizzatori di modelli 3D, convertitori di formati, strumenti di elaborazione geometrica o pipeline 3D lato server possono installarla con un solo comando (vedi la Guida all’installazione) e iniziare immediatamente a caricare, costruire ed esportare contenuti 3D. La libreria utilizza require('fs') e Buffer di Node.js; l’uso nel browser richiede shim appropriati per quelle API e non è ufficialmente supportato.

La libreria supporta i principali formati di interscambio — OBJ, glTF 2.0 / GLB, STL, 3MF e COLLADA sia per l’importazione che per l’esportazione. Esistono classi di import/export FBX ma non sono ancora integrate nella rilevazione automatica dei formati. Il API del grafo della scena rispecchia il modello familiare agli strumenti di authoring 3D: un Scene contiene un rootNode, ogni Node può contenere nodi figli e oggetti entità (Mesh, Camera, Light), e la gerarchia di trasformazione è completamente accessibile per lettura e scrittura.

Caratteristiche principali

  • I/O multi-formato: Importa ed esporta OBJ (con .mtl materiali), glTF 2.0 / GLB, STL (binario e ASCII), 3MF e COLLADA sia da percorsi file che in memoria Buffer oggetti. Il supporto FBX non è ancora integrato nella rilevazione automatica.
  • grafo della scena API: Scene, Node, Mesh, Camera, Light gerarchia con gestione completa di genitori/figli; attraversa i nodi ricorsivamente tramite node.childNodes
  • sistema di materiali PBR: materiali Lambert, Phong e PBR (metallico/ruvidità) accessibili tramite node.material
  • Operazioni di mesh: Accedi ai dati grezzi dei vertici tramite mesh.controlPoints (array di Vector4), indici dei poligoni tramite mesh.polygonCount, e canali degli elementi dei vertici tramite mesh.getElement()
  • Utilità matematiche: Vector2, Vector3, Vector4, Matrix4, Quaternion, e tipi di bounding box per calcoli spaziali
  • Sistema di animazione:Animazione keyframe con AnimationClip, AnimationChannel, e curve di interpolazione (lineare, Bezier, spline TCB)
  • Opzioni specifiche del formato: Per-formato LoadOptions / SaveOptions Le classi controllano l’inversione delle coordinate, la scala, il caricamento dei materiali e altro

Guida introduttiva

Compila il pacchetto dal sorgente. Node.js 18 o successivo è necessario; TypeScript 5.0+ è consigliato.

git clone https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-TypeScript.git
cd Aspose.3D-FOSS-for-TypeScript
npm install
npm run build

Carica un file OBJ e ispeziona la scena:

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';

const scene = new Scene();
const options = new ObjLoadOptions();
options.enableMaterials = true;
scene.open('model.obj', options);

for (const node of scene.rootNode.childNodes) {
    if (node.entity && 'controlPoints' in node.entity) {
        const mesh = node.entity as any;
        console.log(`Mesh "${node.name}": ${mesh.controlPoints.length} vertices`);
    }
}

Albero della scena API

Ogni scena è un albero di oggetti Node con radice in scene.rootNode. Costruisci la gerarchia con addChildNode(), collega entità come Camera o Light a un nodo tramite la sua proprietà entity, e leggi la trasformazione locale o nello spazio globale di ciascun nodo tramite transform e globalTransform.

import { Scene, Node, Camera, Light } from '@aspose/3d';

const scene = new Scene();

const cameraNode = new Node('MainCamera');
cameraNode.entity = new Camera('MainCamera');
scene.rootNode.addChildNode(cameraNode);

const lightNode = new Node('KeyLight');
lightNode.entity = new Light('KeyLight');
scene.rootNode.addChildNode(lightNode);

for (const child of scene.rootNode.childNodes) {
    console.log(`${child.name}: ${child.entity?.constructor.name}`);
}

Utility matematiche

Vector3, Vector4, Matrix4 e Quaternion supportano ogni operazione geometrica nella libreria. Vector3 e Vector4 espongono componenti x/y/z(/w) oltre a length, dot() e cross(); Matrix4 è una griglia 4×4 accessibile tramite m00–m33 con transpose() e concatenate(); Quaternion fornisce normalize(), conjugate(), inverse() e dot() per la matematica delle rotazioni.

import { Vector3, Quaternion, Matrix4 } from '@aspose/3d/utilities';

const position = new Vector3(1.0, 2.0, 3.0);
const rotation = new Quaternion(1.0, 0.0, 0.0, 0.0);
const transform = new Matrix4();

console.log(`length=${position.length} determinant=${transform.determinant}`);
console.log(`rotation w=${rotation.w} x=${rotation.x} y=${rotation.y} z=${rotation.z}`);

Vedi anche

Risorse correlate