Werken met de Scene Graph

Elke 3D-scenario in Aspose.3D voor Java wordt georganiseerd als een boom van de Node voorwerpen . Scene Een enkele rood – getRootNode() - en elk stukje geometrie, materiaal en leven onder die wortel veranderen als een kind of naaste node.

Het maken van het podium en toegang tot de rotsnode

Scene initialiseren automatisch met een roodnode genaamd "RootNode":

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

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

Kinderen Nodes toevoegen

Calling op createChildNode() op elke knop om een kind toe te voegen. de methode heeft drie meestal gebruikte overloads:

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

Om een knop toe te voegen die apart is gebouwd, gebruik addChildNode():

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

Kinderen zoeken Nodes

Vind een direct kind per naam of index, of iterate alle directe kinderen:

// 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) Zoek alleen Direct kinderen,niet de hele ondergrondse. note dat accept() bezoekt alleen de zogenaamde node; iterate getChildNodes() Opnieuw zoeken we de hele boom.

Door de volle boom te gaan

node.accept(NodeVisitor) bezoekt alleen de zogenaamde knop - het herstelt niet naar kinderen. om de volle boom te kruisen, iterate getChildNodes() terugkeren. de bezoeker komt terug true om te blijven of false Om vroeg te stoppen:

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 is een enkelmethode-interface, dus het accepteert een lambda in Java 8+.

Controle van zichtbaarheid en uitvoerexclusie

Nodes kunnen verborgen of uit de export worden gesloten zonder van de hiërarchie te worden verwijderd:

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) Het is een display. setExcluded(true) voorkomt dat de knop verschijnt in geëxporteerde bestanden, ongeacht het formaat.

Vermijd meerdere entiteiten aan één node

Een node heeft een Primaire De entiteit (getEntity() / setEntity()( ) maar kan extra entiteiten door middel van addEntity().Dit is nuttig wanneer verschillende mesh stukken een enkele transformatie delen:

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

Verwijderde noden

merge() verplaatsen alle kinderen, entiteiten en materialen van een bronnod naar de doel-node.:

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

API snelle referentie

lid	Beschrijving
`scene.getRootNode()`	Root van de scène boom; altijd aanwezig na `new Scene()`
`node.createChildNode(name)`	Creëren van een naamgebaseerde kinderknop met geen entiteit
`node.createChildNode(name, entity)`	Creëren van een naam kind node met een entiteit
`node.createChildNode(name, entity, material)`	Creëer een naamgebaseerde kinderknop met entiteit en materiaal
`node.addChildNode(node)`	Een afzonderlijk gebouwde `Node`
`node.getChild(name)`	Vind een direct kind per naam; terugkeer `null` Als je niet gevonden
`node.getChild(index)`	Neem het rechtstreekse kind op een gegeven index
`node.getChildNodes()`	`List<Node>` van alle directe kinderen
`node.accept(visitor)`	Bezoek alleen deze knop (geet niet terug naar kinderen)
`node.addEntity(entity)`	Voeg een extra entiteit aan bij de knop toe
`node.getEntities()`	`List<Entity>` van alle entiteiten op deze node
`node.setVisible(bool)`	Zie of verbergen de knop
`node.setExcluded(bool)`	Inclusie of uitsluiting van de knoop uit export
`node.merge(other)`	Alle kinderen en entiteiten verplaatsen van de `other` In deze node