Cómo crear una 3D Mesh programáticamente en TypeScript

Paso 1: Instalar @aspose/3d

npm install @aspose/3d

No se requieren complementos nativos ni bibliotecas del sistema. El paquete incluye definiciones de tipos de TypeScript.

Mínimo tsconfig.json:

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

Paso 2: Crear una escena y un nodo

Un Scene es el contenedor de nivel superior. Toda la geometría debe estar adjunta a un Node dentro del árbol de escena:

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

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

createChildNode(name) crea un nodo con nombre y lo enlaza como hijo del nodo actual. El objeto Node devuelto es donde adjuntarás la malla en el Paso 7.

Paso 3: Crear un objeto Mesh

Mesh contiene posiciones de vértices y definiciones de polígonos. Construye uno con un nombre opcional:

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

const mesh = new Mesh('triangle');

La malla comienza vacía: sin vértices y sin caras. Los añades en los siguientes pasos.

Paso 4: Añadir puntos de control (vértices)

Los puntos de control son las posiciones de los vértices en el espacio local. Empuje los valores Vector4 a mesh.controlPoints. El cuarto componente (w) es 1 para las posiciones:

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

Usted hace referencia a estas posiciones mediante su índice basado en cero al definir caras de polígonos.

Paso 5: Crear caras de polígono

createPolygon() define una cara enumerando los índices de los vértices en orden. Tres índices forman un triángulo:

mesh.createPolygon(0, 1, 2);

También puedes definir quads (cuatro índices) o polígonos arbitrarios para los formatos que los admiten. Para glTF, la biblioteca triangulará automáticamente los quads y n-gons al exportar.

Paso 6: Añadir normales de vértice

Los normales mejoran la calidad del renderizado. Use mesh.createElement() para crear un VertexElementNormal, recopile los vectores normales en una matriz, luego llame a setData() para almacenarlos. El getter data devuelve una copia defensiva — agregar elementos a ella no tiene efecto. Use FVector3 (float de precisión simple) para los datos de normales, no 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 significa una normal por vértice. ReferenceMode.DIRECT significa que la matriz de datos está indexada directamente por el índice del vértice del polígono.

Paso 7: Adjuntar la malla y guardar en glTF

Asigne la malla al nodo mediante node.entity, luego guarde la escena:

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');

Para producir un único archivo .glb autocontenido en su lugar, establezca saveOpts.binaryMode = true y cambie la extensión del archivo de salida a .glb.