Lucrarea cu Scene Graph

Fiecare scenă 3D din Aspose.3D pentru Java este organizată ca un copac de Node Obiectele . Scene Un singur rădăcină - getRootNode() - şi fiecare piesă de geometrie, material şi transformare a vieţii sub acea rădăcină ca un copil sau un nod descendent.

Crearea scenei și accesul la nodul de rădăcină

Scene Inițializează automat cu un nod de rădăcină numit "RootNode":

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

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

Adăugarea nodurilor pentru copii

apeluri createChildNode() pe orice nod pentru a adăuga un copil. metoda are trei încărcături frecvent utilizate:

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

Pentru a adăuga un nod care a fost construit separat, utilizați addChildNode():

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

Caută copii noduri

Găsiți un copil direct prin nume sau index, sau iterați toate copiii direcți:

// 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) Căutarea numai Copiii direcți,Nu în subteranul complet. Țineți cont de acest lucru accept() vizitează numai numit nod; iterate getChildNodes() Încă o dată, să caute întregul copac.

Călătorește prin copacul plin

node.accept(NodeVisitor) vizitează numai așa-numitul nod - nu se recurge la copii. pentru a traversa copacul plin, iterate getChildNodes() Întoarceți vizitatorul înapoi true pentru a continua sau false Pentru a opri mai devreme:

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 este o interfață de unică metodă, deci acceptă o lambda în Java 8+.

Controlul vizibilității și excluderea exporturilor

Node pot fi ascuns sau excluse din export fără a fi îndepărtate de ierarhie:

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) Este un indicator de afișare. setExcluded(true) previne apariția nodului în fișierele exportate, indiferent de format.

Adăugarea mai multor entități la un singur nod

Un nod are o Primară Întreprinderea (getEntity() / setEntity()(c) poate avea în vedere alte entități prin addEntity().Acest lucru este util atunci când diferite bucăți de mesh împărtășesc o singură transformare:

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

Node înclinate

merge() Se mişcă toate copiii, entităţile şi materialele dintr-un nod de sursă în nodul țintă.:

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

Referință rapidă API

Membru	Descriere
`scene.getRootNode()`	Rădăcinile copacului de scenă; întotdeauna prezent după `new Scene()`
`node.createChildNode(name)`	Creați un nod de copil cu nume fără entitate
`node.createChildNode(name, entity)`	Creați un nod de copil numit cu o entitate
`node.createChildNode(name, entity, material)`	Creați un nod de copil numit cu entitate și material
`node.addChildNode(node)`	Un proiect construit separat `Node`
`node.getChild(name)`	Găsiți un copil direct după nume; întoarceți `null` Dacă nu se găseşte
`node.getChild(index)`	Obțineți copilul direct la un anumit index
`node.getChildNodes()`	`List<Node>` Pentru toate copiii directe
`node.accept(visitor)`	Vizitați numai acest nod (nu se recurge la copii)
`node.addEntity(entity)`	Adăugați o entitate suplimentară la nodul
`node.getEntities()`	`List<Entity>` toate entitățile din acest nod
`node.setVisible(bool)`	Arătați sau ascundeți nodul
`node.setExcluded(bool)`	Include sau exclude nodul din export
`node.merge(other)`	Măsura tuturor copiilor şi entităţilor din `other` În acest nod