Wie man ein 3D‑Mesh programmgesteuert in TypeScript erstellt

Schritt 1: Installieren @aspose/3d

npm install @aspose/3d

Keine nativen Add‑ons oder Systembibliotheken sind erforderlich. Das Paket enthält TypeScript‑Typdefinitionen.

Minimum tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true
  }
}

Schritt 2: Erstelle eine Szene und einen Knoten

Ein Scene ist der oberste Container. Alle Geometrie muss an einem Node innerhalb des Szenenbaums angehängt werden:

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

const scene = new Scene();
const node = scene.rootNode.createChildNode('triangle');

createChildNode(name) erstellt einen benannten Knoten und verbindet ihn als Kind des aktuellen Knotens. Das zurückgegebene Node‑Objekt ist der Ort, an dem Sie das Mesh in Schritt 7 anhängen.

Schritt 3: Mesh-Objekt erstellen

Mesh enthält Scheitelpunktpositionen und Polygon‑Definitionen. Erstelle ein solches mit einem optionalen Namen:

import { Mesh } from '@aspose/3d/entities';

const mesh = new Mesh('triangle');

Das Mesh beginnt leer: keine Scheitelpunkte und keine Flächen. Sie fügen sie in den nächsten Schritten hinzu.

Schritt 4: Kontrollpunkte hinzufügen (Scheitelpunkte)

Kontrollpunkte sind die Scheitelpunktpositionen im lokalen Raum. Schieben Sie Vector4 Werte in mesh.controlPoints. Die vierte Komponente (w) ist 1 für Positionen:

import { Vector4 } from '@aspose/3d/utilities';

mesh.controlPoints.push(new Vector4(0.0, 0.0, 0.0, 1.0)); // index 0
mesh.controlPoints.push(new Vector4(1.0, 0.0, 0.0, 1.0)); // index 1
mesh.controlPoints.push(new Vector4(0.5, 1.0, 0.0, 1.0)); // index 2

Sie referenzieren diese Positionen über deren nullbasierten Index, wenn Sie Polygonflächen definieren.

Schritt 5: Polygonflächen erstellen

createPolygon() definiert ein Face, indem die Scheitelpunktindizes in Reihenfolge aufgelistet werden. Drei Indizes ergeben ein Dreieck:

mesh.createPolygon(0, 1, 2);

Sie können auch Quads (vier Indizes) oder beliebige Polygone für Formate definieren, die sie unterstützen. Für glTF trianguliert die Bibliothek beim Export automatisch Quads und N‑Gons.

Schritt 6: Vertex‑Normalen hinzufügen

Normalen verbessern die Rendering‑Qualität. Verwenden Sie mesh.createElement(), um ein VertexElementNormal zu erstellen, sammeln Sie Normalenvektoren in einem Array und rufen Sie dann setData() auf, um sie zu speichern. Der data‑Getter gibt eine defensive Kopie zurück – das Hinzufügen zu ihr hat keine Wirkung. Verwenden Sie FVector3 (Single‑Precision‑Float) für Normaldaten, nicht Vector4.

import { VertexElementNormal } from '@aspose/3d/entities';
import { VertexElementType, MappingMode, ReferenceMode } from '@aspose/3d/entities';
import { FVector3 } from '@aspose/3d/utilities';

const normals = mesh.createElement(
    VertexElementType.NORMAL,
    MappingMode.CONTROL_POINT,
    ReferenceMode.DIRECT
) as VertexElementNormal;

// Build the normal array, then call setData() — do NOT push to normals.data
normals.setData([
    new FVector3(0, 0, 1), // normal for vertex 0 (pointing +Z)
    new FVector3(0, 0, 1), // normal for vertex 1
    new FVector3(0, 0, 1), // normal for vertex 2
]);

MappingMode.CONTROL_POINT bedeutet ein Normal pro Scheitelpunkt. ReferenceMode.DIRECT bedeutet, dass das Datenarray direkt über den Polygon‑Scheitelpunkt‑Index indiziert wird.

Schritt 7: Mesh anhängen und als glTF speichern

Weisen Sie das Mesh dem Knoten über node.entity zu, dann speichern Sie die Szene:

import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

node.entity = mesh;

const saveOpts = new GltfSaveOptions();
scene.save('triangle.gltf', GltfFormat.getInstance(), saveOpts);
console.log('Triangle mesh saved to triangle.gltf');

Um stattdessen eine einzelne eigenständige .glb‑Datei zu erzeugen, setzen Sie saveOpts.binaryMode = true und ändern Sie die Ausgabedateierweiterung zu .glb.