Funcionalitats clau de Aspose.3D FOSS per a Java

En el 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 gràfic d’escena

El gràfic de l’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.

Escena

La Scene classe és el punt d’entrada per a totes les operacions. Podeu 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 mitjançant getRootNode().

Node

Un Node representa una posició amb nom a l’arbre de l’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);

Entitat i Malla

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

Nota: El Camera classe a l’edició Java és un esquelet mínim només amb constructors. Les entitats de càmera adjuntes als nodes són no escrites en exportar a glTF o qualsevol altre format — l’exportador glTF processa només Mesh entitats. No depengueu que les dades de la càmera es conservin en els fitxers exportats.

Nota: La Light la classe no està disponible a l’edició Java. Les dades d’il·luminació de l’escena procedents de fitxers importats s’emmagatzemen com a genèrics 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) a través de PbrMaterial. Aquesta és l’única classe de material concreta a l’edició Java.

PbrMaterial

Un material de renderització basat físicament que utilitza paràmetres d’albedo, metal·linitat 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 es mapen naturalment a la sortida glTF i GLB.

Transform i Spatial

Cada Node al gràfic de l’escena té un Transform que defineix la seva posició, rotació i escala respecte al 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 d’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 translació, rotació i 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. Els 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’escenes.

BoundingBox bbox = new BoundingBox();
// BoundingBox can be constructed directly with min/max Vector3 values

Nota: Node.getBoundingBox() i Entity.getBoundingBox() encara no s’han implementat. Ambdues retornen un buit BoundingBox (amb valors sentinel Double.MAX_VALUE / Double.MIN_VALUE valors) independentment de la geometria de la malla. No utilitzeu aquests mètodes per calcular els límits reals de la geometria en aquesta versió.

Limitacions conegudes

Cal destacar 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.