Arbeide med scenegrafen

Hver 3D‑scene i Aspose.3D for Java er organisert som et tre av Node objekter. Scene gir en enkelt rot — getRootNode() — og hver del av geometri, materiale og transformasjon lever under den roten som et barn‑ eller etterkommernode.

Opprette scenen og få tilgang til rotnoden

Scene initialiseres automatisk med en rotnode med navnet "RootNode":

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

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

Legge til undernoder

Call createChildNode() på en hvilken som helst node for å legge til et barn. Metoden har tre vanlig brukte overbelastninger:

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

For å feste en node som ble konstruert separat, bruk addChildNode():

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

Forespør undernoder

Finn en direkte undernode etter navn eller etter indeks, eller iterer over alle direkte undernoder:

// 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) søker kun direkte barn, ikke hele deltreet. Bruk accept() for å søke i hele treet.

Traversere hele treet

node.accept(NodeVisitor) går gjennom en node og alle dens etterkommere i dybde‑først rekkefølge. Besøkende returnerer true for å fortsette eller false for å stoppe tidlig:

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 er et enkeltmetode‑grensesnitt, så den godtar en lambda i Java 8+.

Styre synlighet og ekskludering ved eksport

Noder kan skjules eller ekskluderes fra eksport uten å bli fjernet fra hierarkiet:

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) er et visningstips. setExcluded(true) hindrer at noden vises i eksporterte filer uansett format.

Knytte flere enheter til én node

En node har en primær entitet (getEntity() / setEntity()), men kan holde flere entiteter gjennom addEntity(). Dette er nyttig når forskjellige mesh-deler deler en enkelt transformasjon:

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

Slå sammen noder

merge() flytter alle barn, entiteter og materialer fra en kildenode til mål‑noden. Kildenoden blir stående tom:

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

Neste steg

Anvende Transformasjoner — posisjonere, rotere og skalere enhver node ved hjelp av dens Transform
Opprette og Arbeide med Meshes — bygg polygongeometri og fest den til noder

API‑hurtigreferanse

Medlem	Beskrivelse
`scene.getRootNode()`	Roten av scenetreet; alltid tilstede etter `new Scene()`
`node.createChildNode(name)`	Opprett en navngitt barnenode uten entitet
`node.createChildNode(name, entity)`	Opprett en navngitt barnenode med en entitet
`node.createChildNode(name, entity, material)`	Opprett en navngitt barnenode med entitet og materiale
`node.addChildNode(node)`	Fest en separat konstruert `Node`
`node.getChild(name)`	Finn et direkte barn etter navn; returnerer `null` hvis ikke funnet
`node.getChild(index)`	Hent det direkte barnet på en gitt indeks
`node.getChildNodes()`	`List<Node>` av alle direkte barn
`node.accept(visitor)`	Gå gjennom denne noden og alle etterkommere i dybde-første rekkefølge
`node.addEntity(entity)`	Legg til en ekstra enhet til noden
`node.getEntities()`	`List<Entity>` av alle enheter på denne noden
`node.setVisible(bool)`	Vis eller skjul noden
`node.setExcluded(bool)`	Inkluder eller ekskluder noden fra eksport
`node.merge(other)`	Flytt alle underordnede og enheter fra `other` inn i denne noden