Scene Graf

Jede 3D-Szenen in Aspose.3D für Java wird als ein Baum der Node Gegenstände. Scene Ein einziger Rötung - getRootNode() - und jedes Stück Geometrie, Material und Transformation von Leben unter diesem Wurzel als Kind oder Nachkommen Node.

Erstellen der Bühne und Zugang zum Root Node

Scene initialisiert automatisch mit einem Wurzelnode namens "RootNode":

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

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

Kinder Node hinzufügen

Anruf createChildNode() auf jeder Knoten, um ein Kind hinzuzufügen. Die Methode hat drei häufig verwendete Überlastungen:

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

Um einen Knoten zu fügen, der separat gebaut wurde, verwenden Sie addChildNode():

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

Kinder Node suchen

Finden Sie ein direktes Kind nach Namen oder Index oder iterieren Sie alle direkten Kinder:

// 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) Nur Such Direkt Kinder,nicht das ganze Unterwasser.Nachmerke, dass accept() nur die sogenannte Node besucht; iterate getChildNodes() Wiederholen und die ganze Baum suchen.

Über den Volltree

node.accept(NodeVisitor) besucht nur die sogenannte Node – sie kehrt nicht in die Kinder zurück. getChildNodes() Rückkehr: Der Besucher kehrt zurück true Weiterhin oder false Zu früh aufhören:

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 ist eine einzigartige Schnittstelle, so dass es eine Lambda in Java 8+ akzeptiert.

Überprüfung der Sichtbarkeit und Export-Exklusion

Noten können ohne die Hierarchie verborgen oder aus dem Export ausgeschlossen werden:

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) Es ist ein Display. setExcluded(true) verhindert, dass die Node in exportierten Dateien unabhängig von Format erscheint.

Mehrere Einheiten zu einem Node zu verbinden

Ein Node hat eine Primär Einheit (getEntity() / setEntity()( ) kann aber zusätzliche Einheiten durch addEntity().Dies ist nützlich, wenn verschiedene Messerteile eine einzelne Transformation teilen:

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 zu vertreiben

merge() bewegt alle Kinder, Einheiten und Materialien von einem Quellknoten in den Zielknoten.:

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

Feuerreferenz

Mitglied	Beschreibung
`scene.getRootNode()`	Wurzel des Drehbaums; immer vor Ort nach `new Scene()`
`node.createChildNode(name)`	Erstellen Sie einen namensgebundenen Kind node ohne Entität
`node.createChildNode(name, entity)`	Erstellen eines namensgebundenen Kindens node mit einer entität
`node.createChildNode(name, entity, material)`	Erstellen Sie einen namensgebundenen Kind node mit entität und material
`node.addChildNode(node)`	Ein separat gebautes `Node`
`node.getChild(name)`	Finden Sie ein direktes Kind nach Namen; Rückkehr `null` Wenn nicht gefunden
`node.getChild(index)`	Erhalten Sie das direkte Kind auf einem bestimmten Index
`node.getChildNodes()`	`List<Node>` von allen direkten Kindern
`node.accept(visitor)`	Besuchen Sie nur diese Node (keine Rückkehr in Kinder)
`node.addEntity(entity)`	Anschließen Sie eine zusätzliche Einheit an den Knoten
`node.getEntities()`	`List<Entity>` Alle Einheiten in diesem Knoten
`node.setVisible(bool)`	Zeigen oder verstecken Sie den Knoten
`node.setExcluded(bool)`	Inkludieren oder ausschließen Sie den Node aus dem Export
`node.merge(other)`	Alle Kinder und Einheiten von `other` In diesen Node