Key Features of Aspose.3D FOSS for Java

Al publicació d’introducció, vam cobrir què és Aspose.3D FOSS per a Java i com començar. Aquesta publicació aprofundeix en les característiques clau que conformen la biblioteca, amb exemples de codi per a cada àrea.

Tots els exemples assumeixen la següent importació:

import com.aspose.threed.*;

I la dependència Maven:

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

API del Scene Graph

El gràfic d’escena és la base de Aspose.3D FOSS per a Java. Cada model 3D — tant si es carrega des d’un fitxer com si es construeix programàticament — es representa com un arbre de nodes arrelat en un Scene objecte.

Scene

La Scene classe és el punt d’entrada per a totes les operacions. Pots crear una escena buida o carregar-ne una des d’un fitxer:

// 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());

L’arrel de l’arbre de nodes s’accedeix a través de getRootNode().

Node

A Node representa una posició amb nom a l’arbre d’escena. Els nodes poden tenir fills, formant una jerarquia. Cada node porta un local Transform i un calculat 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");

També pots construir nodes de manera independent i adjuntar-los més tard:

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

Entity and Mesh

Un Entity és una classe base abstracta per a qualsevol cosa que es pugui adjuntar a un node – geometria, càmeres i llums. El tipus d’entitat més comú és Mesh, que conté geometria poligonal (vèrtexs, cares i normals).

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àmera

Les càmeres són entitats que s’adjunten a nodes:

Scene scene = new Scene();

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

Les definicions de càmera es conserven en exportar a formats que les admeten (com ara glTF).

Nota: La Light classe no està disponible a l’edició Java. Les dades d’il·luminació de l’escena dels fitxers importats s’emmagatzemen com a genèriques Entity objectes.

Càrrega i desament independents del format

Un dels punts forts de la biblioteca és que el gràfic d’escena és independent del format. Carregues des de qualsevol format compatible, manipules l’escena a través d’una única API i deses a qualsevol format 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 format es determina per l’extensió del fitxer. També pots passar opcions de desament explícites per controlar la sortida:

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

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

Materials

Aspose.3D FOSS per a Java ofereix un model de material PBR (Physically Based Rendering) via PbrMaterial. Aquesta és l’única classe de material concret a l’edició Java edition.

PbrMaterial

Un material de renderització basada en la física que utilitza paràmetres d’albedo, metal·licitat i rugositat. Aquest és el model de material estàndard per a glTF i motors temps real moderns.

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ó del material entre formats depèn de les capacitats del format de destinació. Els materials PBR s’assignen de manera natural a la sortida glTF i GLB.

Transform i Spatial

Cada Node en el gràfic de escena té un Transform que defineix la seva posició, rotació i escala respecte del seu pare.

Transformació 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

Transformació Global

El GlobalTransform és la transformació calculada en l’espai mundial, tenint en compte tota la cadena de pares. Això és només de lectura i s’actualitza automàticament.

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

Aquesta herència de transformació pare-filla segueix el patró estàndard de gràfic de escena utilitzat per motors 3D i eines DCC.

Utilitats Matemàtiques

La biblioteca inclou tipus matemàtics bàsics per a operacions 3D.

Vector3

Un vector de tres components utilitzat per a posicions, direccions, normals i colors.

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 matriu de transformació 4x4 per combinar la translació, la rotació i l’escala en una única operació.

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

Quaternion

Una representació de rotació que evita el bloqueig de gimbal i s’interpola de manera suau. Quaternions s’utilitzen internament pel sistema de transformació.

BoundingBox

Una caixa delimitadora alineada amb els eixos per a consultes espacials, comprovacions de col·lisió i anàlisi d’escena.

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

Limitacions conegudes

Cal tenir en compte que Scene.render() és no és compatible a l’edició FOSS. Cridar-lo generarà una UnsupportedOperationException. La biblioteca està dissenyada per al processament 3D basat en fitxers – càrrega, transformació i desament – més que per al renderitzat en temps real.

Resum

Les característiques clau de Aspose.3D FOSS per a Java es desglossen en cinc àrees:

En la propera publicació, revisarem tutorials pràctics format per format que cobreixen OBJ, STL, glTF i FBX amb opcions detallades de càrrega i desament.