Características clave de Aspose.3D FOSS para Java

En el publicación de introducción, cubrimos qué es Aspose.3D FOSS para Java y cómo comenzar. Esta publicación profundiza en las características clave que componen la biblioteca, con ejemplos de código para cada área.

Todos los ejemplos asumen la siguiente importación:

import com.aspose.threed.*;

Y la dependencia de Maven:

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-3d-foss</artifactId>
    <version>26.1.0</version>
</dependency>

API de Grafo de Escena

El grafo de escena es la base de Aspose.3D FOSS para Java. Cada modelo 3D — ya sea cargado desde un archivo o construido programáticamente — se representa como un árbol de nodos enraizado en un Scene objeto.

Escena

La Scene clase es el punto de entrada para todas las operaciones. Puedes crear una escena vacía o cargar una desde un archivo:

// Empty scene
Scene scene = new Scene();

// Load from file
Scene loaded = Scene.fromFile("model.obj");

// Load with explicit options
Scene fromStl = Scene.fromFile("part.stl", new StlLoadOptions());

La raíz del árbol de nodos se accede mediante getRootNode().

Nodo

Un Node representa una posición nombrada en el árbol de escena. Los nodos pueden tener hijos, formando una jerarquía. Cada nodo lleva un local Transform y un calculado GlobalTransform.

Scene scene = new Scene();

// Create a child node under the root
Node box = scene.getRootNode().createChildNode("Box");

// Create a nested hierarchy
Node arm = scene.getRootNode().createChildNode("Arm");
Node hand = arm.createChildNode("Hand");
Node finger = hand.createChildNode("Finger");

También puedes construir nodos de forma independiente y adjuntarlos más tarde:

Node standalone = new Node("Standalone");
scene.getRootNode().getChildNodes().add(standalone);

Entidad y Malla

Un Entity es una clase base abstracta para cualquier cosa que pueda adjuntarse a un nodo – geometría, cámaras y luces. El tipo de entidad más común es Mesh, que contiene geometría poligonal (vértices, caras y normales).

Scene scene = Scene.fromFile("cube.obj");

// Traverse nodes and inspect entities
for (Node child : scene.getRootNode().getChildNodes()) {
    Entity entity = child.getEntity();
    if (entity instanceof Mesh) {
        Mesh mesh = (Mesh) entity;
        System.out.println("Node: " + child.getName());
        System.out.println("  Vertices: " + mesh.getControlPoints().size());
    }
}

Cámara

Las cámaras son entidades que se adjuntan a nodos:

Scene scene = new Scene();

Node cameraNode = scene.getRootNode().createChildNode("MainCamera");
// Camera entity can be assigned to the node

Las definiciones de cámara se conservan al exportar a formatos que las admiten (como glTF).

Nota: El Light class no está disponible en la edición Java. Los datos de iluminación de la escena de los archivos importados se almacenan como genéricos Entity objetos.

Carga y Guardado Independientes del Formato

Una de las fortalezas de la biblioteca es que el grafo de escena es independiente del formato. Cargas desde cualquier formato compatible, manipulas la escena a través de una única API y guardas en cualquier formato compatible.

// Load OBJ, save as glTF
Scene scene = Scene.fromFile("input.obj");
scene.save("output.gltf");

// Load FBX, save as STL (FBX is import only)
Scene scene2 = Scene.fromFile("character.fbx");
scene2.save("character.stl");

// Load STL, save as GLB
Scene scene3 = Scene.fromFile("part.stl", new StlLoadOptions());
GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);
scene3.save("part.glb", opts);

El formato se determina por la extensión del archivo. También puedes pasar opciones de guardado explícitas para controlar la salida:

GltfSaveOptions opts = new GltfSaveOptions();
opts.setFlipCoordinateSystem(true);
opts.setPrettyPrint(true);

scene.save("output.gltf", opts);

Materiales

Aspose.3D FOSS para Java ofrece un modelo de material PBR (Physically Based Rendering) a través de PbrMaterial. Esta es la única clase de material concreta en la edición Java.

PbrMaterial

Un material de renderizado físicamente basado que utiliza los parámetros de albedo, metalicidad y rugosidad. Este es el modelo de material estándar para glTF y los motores en tiempo real modernos.

PbrMaterial pbr = new PbrMaterial();
pbr.setAlbedo(new Vector4(0.8, 0.2, 0.2, 1.0)); // Red-ish base color
pbr.setMetallicFactor(0.0);  // Non-metallic
pbr.setRoughnessFactor(0.5); // Medium roughness

La preservación de materiales entre formatos depende de las capacidades del formato de destino. Los materiales PBR se mapean de forma natural a la salida glTF y GLB.

Transform y Spatial

Cada Node en el grafo de escena tiene un Transform que define su posición, rotación y escala en relación con su padre.

Transform Local

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("TestNode");

Transform t = node.getTransform();
t.setTranslation(1, 2, 3);       // Position
t.setScale(2, 2, 2);             // Uniform scale
t.setEulerAngles(0, 45, 0);      // Euler rotation in degrees

Transform Global

El GlobalTransform es la transformación calculada en espacio mundial, teniendo en cuenta toda la cadena de padres. Es de solo lectura y se actualiza automáticamente.

Node parent = scene.getRootNode().createChildNode("Parent");
parent.getTransform().setTranslation(10, 0, 0);

Node child = parent.createChildNode("Child");
child.getTransform().setTranslation(5, 0, 0);

// Child's global position is (15, 0, 0)
GlobalTransform global = child.getGlobalTransform();

Esta herencia de transformaciones padre-hijo sigue el patrón estándar de grafo de escena utilizado por los motores 3D y las herramientas DCC.

Utilidades Matemáticas

La biblioteca incluye tipos matemáticos básicos para operaciones 3D.

Vector3

Un vector de tres componentes usado para posiciones, direcciones, normales y colores.

Vector3 a = new Vector3(1, 0, 0);
Vector3 b = new Vector3(0, 1, 0);

// Addition
Vector3 sum = Vector3.add(a, b); // (1, 1, 0)

Matrix4

Una matriz de transformación 4x4 para combinar traslación, rotación y escala en una sola operación.

Matrix4 mat = new Matrix4();
// Matrix4 is used internally by transforms
// and can be retrieved from GlobalTransform

Quaternion

Una representación de rotación que evita el bloqueo de gimbal y se interpola suavemente. Los cuaterniones se usan internamente por el sistema de transformación.

BoundingBox

Una caja delimitadora alineada a los ejes para consultas espaciales, verificaciones de colisión y análisis de escena.

BoundingBox bbox = new BoundingBox();
// BoundingBox can be computed from mesh geometry

Limitaciones conocidas

Vale la pena señalar que Scene.render() es no es compatible en la edición FOSS. Llamarlo lanzará una UnsupportedOperationException. La biblioteca está diseñada para el procesamiento 3D basado en archivos – carga, transformación y guardado – en lugar de renderizado en tiempo real.

Resumen

Las características clave de Aspose.3D FOSS para Java se dividen en cinco áreas:

En la próxima publicación, recorreremos tutoriales prácticos formato por formato que cubren OBJ, STL, glTF y FBX con opciones detalladas de carga y guardado.