Introducción

Aspose.3D FOSS para TypeScript (@aspose/3d) es una biblioteca de formatos de archivo 3D de código abierto, con licencia MIT, diseñada principalmente para Node.js. Los desarrolladores que crean visores de modelos 3D, convertidores de formatos, herramientas de procesamiento geométrico o canalizaciones 3D del lado del servidor pueden instalarla con un solo comando (consulte la Guía de instalación) y comenzar de inmediato a cargar, construir y exportar contenido 3D. La biblioteca usa require('fs') y Buffer de Node.js; el uso en navegadores requiere los shims apropiados para esas API y no está soportado oficialmente.

La biblioteca admite los principales formatos de intercambio — OBJ, glTF 2.0 / GLB, STL, 3MF y COLLADA tanto para importación como para exportación. Existen clases de importador/exportador FBX pero aún no están integradas en la detección automática de formatos. El API del grafo de escena refleja el modelo familiar de las herramientas de autoría 3D: un Scene contiene un rootNode, cada Node puede portar nodos hijos y objetos de entidad (Mesh, Camera, Light), y la jerarquía de transformaciones es totalmente accesible para lectura y escritura.

Características principales

  • Entrada/Salida multiformato: Importar y exportar OBJ (con .mtl materiales), glTF 2.0 / GLB, STL (binario y ASCII), 3MF y COLLADA tanto desde rutas de archivo como en memoria Buffer objetos. El soporte FBX aún no está integrado en la detección automática.
  • Grafo de escena API: Scene, Node, Mesh, Camera, Light jerarquía con gestión completa de padres/hijos; recorrer nodos recursivamente mediante node.childNodes
  • sistema de materiales PBR: materiales Lambert, Phong y PBR (metallic/roughness) accesibles mediante node.material
  • Operaciones de malla: Acceda a datos de vértice sin procesar a través de mesh.controlPoints (array de Vector4), índices de polígonos a través de mesh.polygonCount, y canales de elementos de vértice a través de mesh.getElement()
  • utilidades matemáticas: Vector2, Vector3, Vector4, Matrix4, Quaternion, y tipos de cajas delimitadoras para cálculos espaciales
  • sistema de animación: Animación de Keyframe con AnimationClip, AnimationChannel, y curvas de interpolación (linear, Bezier, TCB spline)
  • Opciones específicas del formato: Por formato LoadOptions / SaveOptions classes controlan el volteo de coordenadas, escala, carga de materiales y más

Comenzando

Compila el paquete desde el código fuente. Node.js 18 o superior es obligatorio; se recomienda TypeScript 5.0+.

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

Cargar un archivo OBJ y inspeccionar la escena:

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

Grafo de escena API

Cada escena es un árbol de objetos Node con raíz en scene.rootNode. Construya la jerarquía con addChildNode(), adjunte entidades como Camera o Light a un nodo mediante su propiedad entity, y lea la transformación local o del espacio mundial de cada nodo a través de transform y 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}`);
}

Utilidades matemáticas

Vector3, Vector4, Matrix4 y Quaternion respaldan cada operación geométrica en la biblioteca. Vector3 y Vector4 exponen componentes x/y/z(/w) además de length, dot() y cross(); Matrix4 es una cuadrícula 4×4 accesible a través de m00–m33 con transpose() y concatenate(); Quaternion proporciona normalize(), conjugate(), inverse() y dot() para matemáticas de rotación.

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

Ver también

Recursos relacionados