Treballant amb el gràfic d'escena

Treballant amb el gràfic d’escena

Cada escena 3D a Aspose.3D per a Java està organitzada com un arbre de Node objectes. Scene proporciona una única arrel — getRootNode() — i cada peça de geometria, material i transformació viu sota aquesta arrel com a node fill o descendent.

Creant l’escena i accedint al node arrel

Scene s’inicialitza automàticament amb un node arrel anomenat "RootNode":

import com.aspose.threed.Scene;
import com.aspose.threed.Node;

Scene scene = new Scene();
Node root = scene.getRootNode(); // always "RootNode"

Afegint nodes fills

Call createChildNode() en qualsevol node per afegir un fill. El mètode té tres sobrecàrregues d’ús comú:

import com.aspose.threed.*;

Scene scene = new Scene();
Node root = scene.getRootNode();

// 1. Named node with no entity — useful as a pivot or group container
Node pivot = root.createChildNode("pivot");

// 2. Named node with an entity
Mesh mesh = new Mesh("box");
mesh.getControlPoints().add(new Vector4(0, 0, 0));
mesh.getControlPoints().add(new Vector4(1, 0, 0));
mesh.getControlPoints().add(new Vector4(1, 1, 0));
mesh.getControlPoints().add(new Vector4(0, 1, 0));
mesh.createPolygon(0, 1, 2, 3);
Node meshNode = root.createChildNode("box", mesh);

// 3. Named node with entity and material
PbrMaterial mat = new PbrMaterial("red");
mat.setAlbedo(new Vector4(0.8f, 0.2f, 0.2f, 1.0f));
Node decorated = pivot.createChildNode("red_box", mesh, mat);

Per adjuntar un node que s’ha construït per separat, utilitzeu addChildNode():

Node detached = new Node("standalone");
root.addChildNode(detached);

Consultant nodes fills

Troba un fill directe per nom o per índex, o itera tots els fills directes:

// By name — returns null if no direct child has that name
Node found = root.getChild("box");
if (found != null) {
    System.out.println("Found: " + found.getName());
}

// By index
Node first = root.getChild(0);

// Iterate all direct children
for (Node child : root.getChildNodes()) {
    System.out.println(child.getName());
}

getChild(String name) cerca només fills directes, no el subarbre complet. Utilitzeu accept() per cercar tot l’arbre.

Recorregut de tot l’arbre

node.accept(NodeVisitor) recorre un node i tots els seus descendents en ordre de profunditat. El visitant retorna true per continuar o false per aturar-se aviat:

import com.aspose.threed.NodeVisitor;

// Print every node name in the scene
scene.getRootNode().accept(n -> {
    System.out.println(n.getName());
    return true; // false would stop traversal
});

// Stop after finding the first node that has an entity
final Node[] found = {null};
scene.getRootNode().accept(n -> {
    if (n.getEntity() != null) {
        found[0] = n;
        return false; // stop walking
    }
    return true;
});

NodeVisitor és una interfície d’un sol mètode, de manera que accepta una lambda a Java 8+.

Controlant la visibilitat i l’exclusió d’exportació

Els nodes es poden amagar o excloure de l’exportació sense ser eliminats de la jerarquia:

Node ground = root.createChildNode("ground_plane", mesh);
ground.setVisible(false);       // hidden in viewport / renderer

Node helperNode = root.createChildNode("debug_arrow", mesh);
helperNode.setExcluded(true);   // omitted from all export operations

setVisible(false) és una pista de visualització. setExcluded(true) evita que el node aparegui en fitxers exportats independentment del format.

Adjuntar diverses entitats a un node

Un node té un primari entitat (getEntity() / setEntity()), però pot contenir entitats addicionals a través de addEntity(). Això és útil quan diferents peces de malla comparteixen una única transformació:

Mesh body  = new Mesh("body");
Mesh wheel = new Mesh("wheel");

Node carNode = root.createChildNode("car");
carNode.addEntity(body);
carNode.addEntity(wheel);

// Retrieve all entities on this node
for (Entity ent : carNode.getEntities()) {
    System.out.println(ent.getName());
}

Fusionar nodes

merge() Mou tots els fills, entitats i materials d’un node d’origen cap al node de destinació. El node d’origen queda buit:

Node lod0 = root.createChildNode("lod0");
lod0.createChildNode("mesh_high", mesh);

Node lod1 = root.createChildNode("lod1");
lod1.createChildNode("mesh_low", mesh);

// Consolidate lod0 children into lod1
lod1.merge(lod0);
// lod1 now has both mesh_high and mesh_low; lod0 is empty

Propers passos

Aplicació de transformacions — posiciona, gira i escala qualsevol node utilitzant el seu Transform
Creació i treball amb malles — construeix geometria de polígons i adjunta-la als nodes

Referència ràpida de l’API

Membre	Descripció
`scene.getRootNode()`	Arrel de l’arbre d’escena; sempre present després de `new Scene()`
`node.createChildNode(name)`	Crea un node fill anomenat sense cap entitat
`node.createChildNode(name, entity)`	Crea un node fill anomenat amb una entitat
`node.createChildNode(name, entity, material)`	Crea un node fill anomenat amb entitat i material
`node.addChildNode(node)`	Adjunta una construïda per separat `Node`
`node.getChild(name)`	Troba un fill directe per nom; retorna `null` si no es troba
`node.getChild(index)`	Obté el fill directe en un índex donat
`node.getChildNodes()`	`List<Node>` de tots els fills directes
`node.accept(visitor)`	Recorre aquest node i tots els descendents en profunditat primer
`node.addEntity(entity)`	Adjunta una entitat addicional al node
`node.getEntities()`	`List<Entity>` de totes les entitats d’aquest node
`node.setVisible(bool)`	Mostra o amaga el node
`node.setExcluded(bool)`	Inclou o exclou el node de l’exportació
`node.merge(other)`	Mou tots els fills i entitats des de `other` a aquest node