Einleitung

Aspose.3D FOSS für TypeScript (@aspose/3d) ist eine Open-Source-Bibliothek im MIT-Lizenzmodell für 3D-Dateiformate, die primär für Node.js konzipiert wurde. Entwickler, die 3D-Modell-Viewer, Formatkonverter, Geometrieverarbeitungs-Tools oder serverseitige 3D-Pipelines bauen, können sie mit einem einzigen Befehl installieren (siehe die Installationsanleitung) und sofort beginnen, 3D-Inhalte zu laden, zu konstruieren und zu exportieren. Die Bibliothek verwendet require('fs') und Buffer von Node.js; die Nutzung im Browser erfordert geeignete Shims für diese APIs und wird nicht offiziell unterstützt.

Die Bibliothek unterstützt die wichtigsten Austauschformate — OBJ, glTF 2.0 / GLB, STL, 3MF und COLLADA sowohl für Import als auch Export. FBX-Importer/Exporter-Klassen existieren, sind aber noch nicht in die automatische Formaterkennung integriert. Der Szenengraph API spiegelt das aus 3D-Authoring-Tools bekannte Modell wider: ein Scene enthält ein rootNode, jedes Node kann Kindknoten und Entitätsobjekte (Mesh, Camera, Light) tragen, und die Transformationshierarchie ist vollständig les- und schreibbar.

Hauptmerkmale

  • Multi-Format-E/A: Importieren und Exportieren von OBJ (mit .mtl Materialien), glTF 2.0 / GLB, STL (binär und ASCII), 3MF und COLLADA sowohl von Dateipfaden als auch im Speicher Buffer Objekte. FBX-Unterstützung ist noch nicht in die automatische Erkennung integriert.
  • Szenengraph API: Scene, Node, Mesh, Camera, Light Hierarchie mit vollständiger Eltern/Kind-Verwaltung; Knoten rekursiv traversieren über node.childNodes
  • PBR-Materialsystem: Lambert-, Phong- und PBR (metallic/roughness)-Materialien, zugänglich über node.material
  • Mesh-Operationen: Zugriff auf Roh-Vertex-Daten über mesh.controlPoints (Array von Vector4), Polygon-Indizes über mesh.polygonCount, und Vertex-Element-Kanäle über mesh.getElement()
  • Mathe-Hilfsfunktionen: Vector2, Vector3, Vector4, Matrix4, Quaternion, und Bounding-Box-Typen für räumliche Berechnungen
  • Animationssystem:Keyframe-Animation mit AnimationClip, AnimationChannel, und Interpolationskurven (linear, Bezier, TCB-Spline)
  • Formatabhängige Optionen: Pro-Format LoadOptions / SaveOptions Klassen steuern das Umkehren von Koordinaten, Skalierung, Materialladen und mehr

Erste Schritte

Bauen Sie das Paket aus dem Quellcode. Node.js 18 oder höher ist erforderlich; TypeScript 5.0+ wird empfohlen.

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

Lade eine OBJ-Datei und inspiziere die Szene:

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`);
    }
}

Szenengraph API

Jede Szene ist ein Baum von Node-Objekten, verwurzelt bei scene.rootNode. Baue die Hierarchie mit addChildNode() auf, hänge Entitäten wie Camera oder Light an einen Knoten über dessen entity-Eigenschaft an und lese die lokale oder weltweite Transformation jedes Knotens über transform und 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}`);
}

Mathe-Hilfsprogramme

Vector3, Vector4, Matrix4 und Quaternion unterstützen jede geometrische Operation in der Bibliothek. Vector3 und Vector4 stellen x/y/z(/w)-Komponenten plus length, dot() und cross() bereit; Matrix4 ist ein 4×4-Gitter, das über m00–m33 mit transpose() und concatenate() zugänglich ist; Quaternion liefert normalize(), conjugate(), inverse() und dot() für Rotationsmathematik.

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}`);

Siehe auch

Verwandte Ressourcen