Lucrul cu graficul de scenă

Fiecare scenă 3D în Aspose.3D pentru Java este organizată ca un arbore de Node obiecte. Scene furnizează o singură rădăcină — getRootNode() — și fiecare bucată de geometrie, material și transformare trăiește sub acea rădăcină ca un nod copil sau descendent.

Crearea scenei și accesarea nodului rădăcină

Scene se inițializează automat cu un nod 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 copil

Apel createChildNode() pe orice nod pentru a adăuga un copil. Metoda are trei suprasarcini utilizate frecvent:

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 atașa un nod care a fost construit separat, folosiți addChildNode():

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

Interogarea nodurilor copil

Găsește un copil direct după nume sau după index, sau iterează toți 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) caută doar copii direcți, nu întregul subarbore. Utilizați accept() pentru a căuta întregul arbore.

Parcurgerea arborelui complet

node.accept(NodeVisitor) parcurge un nod și toți descendenții săi în ordine adâncime întâi. Vizitatorul returnează true pentru a continua sau false pentru a opri 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ță cu o singură metodă, deci acceptă o lambda în Java 8+.

Controlul vizibilității și excluderea la export

Nodurile pot fi ascunse sau excluse din export fără a fi eliminate din 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 indiciu de afișare. setExcluded(true) previne apariția nodului în fișierele exportate, indiferent de format.

Atașarea mai multor entități la un singur nod

Un nod are un principal entitate (getEntity() / setEntity()), dar poate conține entități suplimentare prin addEntity(). Acest lucru este util atunci când diferite piese 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());
}

Fuzionarea nodurilor

merge() mută toți copiii, entitățile și materialele dintr-un nod sursă în nodul țintă. Nodul sursă rămâne gol:

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

Pașii următori

Aplicarea Transformărilor — poziționează, rotește și scalează orice nod utilizându-i Transform
Crearea și lucrul cu Mesh-uri — construiește geometrie poligonală și atașeaz-o nodurilor

Referință rapidă API

Membru	Descriere
`scene.getRootNode()`	Rădăcina arborelui de scenă; întotdeauna prezentă după `new Scene()`
`node.createChildNode(name)`	Creează un nod copil numit fără entitate
`node.createChildNode(name, entity)`	Creează un nod copil numit cu o entitate
`node.createChildNode(name, entity, material)`	Creează un nod copil numit cu entity și material
`node.addChildNode(node)`	Atașează un element construit separat `Node`
`node.getChild(name)`	Găsește un copil direct după nume; returnează `null` dacă nu este găsit
`node.getChild(index)`	Obține copilul direct la un index dat
`node.getChildNodes()`	`List<Node>` din toți copiii direcți
`node.accept(visitor)`	Parcurge acest nod și toți descendenții în adâncime (depth‑first)
`node.addEntity(entity)`	Atașează o entity suplimentară la nod
`node.getEntities()`	`List<Entity>` din toate entities de pe acest nod
`node.setVisible(bool)`	Afișează sau ascunde nodul
`node.setExcluded(bool)`	Include sau exclude nodul din export
`node.merge(other)`	Mută toate copiii și entitățile din `other` în acest nod