Introdução

Aspose.3D FOSS para TypeScript (@aspose/3d) é uma biblioteca de formatos de arquivo 3D de código aberto, licenciada sob MIT, projetada principalmente para Node.js. Desenvolvedores que criam visualizadores de modelos 3D, conversores de formato, ferramentas de processamento geométrico ou pipelines 3D no lado do servidor podem instalá-la com um único comando (veja o Guia de instalação) e começar imediatamente a carregar, construir e exportar conteúdo 3D. A biblioteca usa require('fs') e Buffer do Node.js; o uso em navegadores requer shims adequados para essas APIs e não é oficialmente suportado.

A biblioteca suporta os principais formatos de intercâmbio — OBJ, glTF 2.0 / GLB, STL, 3MF e COLLADA tanto para importação quanto para exportação. Classes de importador/exportador FBX existem, mas ainda não estão integradas à detecção automática de formatos. O API do grafo de cena reflete o modelo familiar das ferramentas de autoria 3D: um Scene contém um rootNode, cada Node pode conter nós filhos e objetos de entidade (Mesh, Camera, Light), e a hierarquia de transformações está totalmente acessível para leitura e gravação.

Principais recursos

  • E/S multiformato: Importar e exportar OBJ (com .mtl materiais), glTF 2.0 / GLB, STL (binário e ASCII), 3MF e COLLADA a partir de caminhos de arquivo e em memória Buffer objetos. O suporte a FBX ainda não está integrado à detecção automática.
  • Grafo de cena API: Scene, Node, Mesh, Camera, Light hierarquia com gerenciamento completo de pai/filho; percorrer nós recursivamente via node.childNodes
  • sistema de material PBR: Lambert, Phong e materiais PBR (metallic/roughness) acessíveis via node.material
  • Operações de malha: Acesse dados brutos de vértice via mesh.controlPoints (array de Vector4), índices de polígonos via mesh.polygonCount, e canais de elementos de vértice via mesh.getElement()
  • Utilitários matemáticos: Vector2, Vector3, Vector4, Matrix4, Quaternion, e tipos de caixa delimitadora para cálculos espaciais
  • Sistema de animação: Animação por quadros-chave com AnimationClip, AnimationChannel, e curvas de interpolação (linear, Bezier, spline TCB)
  • Opções específicas de formato: Por formato LoadOptions / SaveOptions classes controlam a inversão de coordenadas, escala, carregamento de material e mais

Começando

Compile o pacote a partir do código-fonte. Node.js 18 ou posterior é obrigatório; TypeScript 5.0+ é recomendado.

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

Carregue um arquivo OBJ e inspecione a cena:

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 Cena API

Cada cena é uma árvore de objetos Node enraizada em scene.rootNode. Construa a hierarquia com addChildNode(), anexe entidades como Camera ou Light a um nó via sua propriedade entity, e leia a transformação local ou em espaço mundial de cada nó através de 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}`);
}

Utilitários Matemáticos

Vector3, Vector4, Matrix4 e Quaternion dão suporte a todas as operações geométricas da biblioteca. Vector3 e Vector4 expõem componentes x/y/z(/w) além de length, dot() e cross(); Matrix4 é uma grade 4×4 acessada via m00–m33 com transpose() e concatenate(); Quaternion fornece normalize(), conjugate(), inverse() e dot() para matemática de rotação.

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 também

Recursos Relacionados