Werken met de Scene Graph

Elke 3D‑scène in Aspose.3D voor Java is georganiseerd als een boom van Node objecten. Scene biedt een enkele wortel — getRootNode() — en elk stuk geometrie, materiaal en transformatie bevindt zich onder die wortel als een kind‑ of afstammingsknooppunt.

De scène maken en de rootknoop benaderen

Scene initialiseert automatisch met een wortelknooppunt genaamd "RootNode":

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

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

Kindknopen toevoegen

Call createChildNode() op elk knooppunt om een kind toe te voegen. De methode heeft drie vaak 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 knooppunt dat apart is geconstrueerd toe te voegen, gebruik addChildNode():

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

Kindknopen doorzoeken

Vind een direct kind op naam of op index, of doorloop 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) zoekt alleen directe kinderen, niet de volledige subboom. Gebruik accept() om de hele boom te doorzoeken.

De volledige boom doorlopen

node.accept(NodeVisitor) loopt een knooppunt en al zijn afstammelingen af in diepte‑eerst volgorde. De bezoeker retourneert true om door te gaan of false om vroegtijdig 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 interface met één methode, dus accepteert het een lambda in Java 8+.

Zichtbaarheid en exportuitsluiting beheren

Knopen kunnen verborgen of uitgesloten worden van export zonder uit 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) is een weergavehint. setExcluded(true) voorkomt dat de node verschijnt in geëxporteerde bestanden, ongeacht het formaat.

Meerdere entiteiten aan één knoop koppelen

Een node heeft een primaire entity (getEntity() / setEntity()), maar kan extra entiteiten bevatten via addEntity(). Dit is handig wanneer verschillende mesh-onderdelen 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());
}

Knopen samenvoegen

merge() verplaatst alle kinderen, entiteiten en materialen van een bronknooppunt naar het doelknooppunt. Het bronknooppunt blijft leeg:

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

Volgende stappen

Transformaties toepassen — positioneer, roteer en schaal elk knooppunt met behulp van zijn Transform
Meshes maken en bewerken — bouw polygonale geometrie en koppel deze aan knooppunten

API‑snelreferentie

Lid	Beschrijving
`scene.getRootNode()`	Wortel van de scènetboom; altijd aanwezig na `new Scene()`
`node.createChildNode(name)`	Maak een benoemd kindknooppunt zonder entiteit
`node.createChildNode(name, entity)`	Maak een benoemd kindknooppunt met een entiteit
`node.createChildNode(name, entity, material)`	Maak een benoemd kindknooppunt met entiteit en materiaal
`node.addChildNode(node)`	Koppel een afzonderlijk geconstrueerde `Node`
`node.getChild(name)`	Zoek een direct kind op naam; retourneert `null` indien niet gevonden
`node.getChild(index)`	Haal het directe kind op op een gegeven index
`node.getChildNodes()`	`List<Node>` van alle directe kinderen
`node.accept(visitor)`	Doorloop dit knooppunt en alle afstammelingen in diepte‑eerste volgorde
`node.addEntity(entity)`	Voeg een extra entiteit toe aan de node
`node.getEntities()`	`List<Entity>` van alle entiteiten op deze node
`node.setVisible(bool)`	Toon of verberg de node
`node.setExcluded(bool)`	Neem de node op in of sluit de node uit bij export
`node.merge(other)`	Verplaats alle kinderen en entiteiten van `other` naar deze node