Werken met de Scene Graph

Elke 3D‑scene in Aspose.3D voor .NET is georganiseerd als een boom van Node objecten. Scene.RootNode is de wortel van die boom en elk stuk geometrie, materiaal en transformatie bevindt zich eronder als een kind of afstammeling.

De scène maken en de rootknoop benaderen

Scene initialiseert automatisch met een root node genaamd "RootNode":

using Aspose.ThreeD;

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

Kindknopen toevoegen

Call CreateChildNode() op een willekeurige node om een kind toe te voegen. De methode heeft drie vaak gebruikte overloads:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();
Node root = scene.RootNode;

// 1. Named node with no entity — useful as a pivot or transform container
Node pivot = root.CreateChildNode("pivot");

// 2. Named node with an entity
var box = new Box(2, 2, 2);
Node boxNode = root.CreateChildNode("box", box);

// 3. Named node with entity and material
var mat = new Aspose.ThreeD.Shading.PhongMaterial("red");
mat.Diffuse = new Vector4(0.8, 0.2, 0.2, 1.0);
Node decorated = pivot.CreateChildNode("red_box", box, mat);

Om een apart geconstrueerde node toe te voegen, gebruik AddChildNode():

var 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)
    Console.WriteLine("Found: " + found.Name);

// By index
Node first = root.GetChild(0);

// Iterate all direct children
foreach (Node child in root.ChildNodes)
    Console.WriteLine(child.Name);

GetChild(string name) zoekt alleen directe kinderen, niet de volledige subboom. Gebruik een recursieve helper of Accept() om de hele boom te doorzoeken.

De volledige boom doorlopen

Voor een volledige diepte‑eerste doorloop, itereren ChildNodes recursief:

static void Walk(Node node, int depth = 0)
{
    Console.WriteLine(new string(' ', depth * 2) + node.Name);
    foreach (var child in node.ChildNodes)
        Walk(child, depth + 1);
}

Walk(scene.RootNode);

Voor een early‑exit traversie, node.Accept(NodeVisitor) is beschikbaar en roept de visitor aan op elke afstammeling totdat de visitor terugkeert false.

Groep gebruiken om gerelateerde objecten te organiseren

Group is een container‑entity die nodes logisch organiseert zonder geometrie toe te voegen. Bevestig het aan een node waarvan de kinderen een logische eenheid vertegenwoordigen:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();

// A group node for all furniture in a room
var furnitureGroup = new Group("furniture");
Node roomNode = scene.RootNode.CreateChildNode("living_room", furnitureGroup);

// Child nodes under the group node
Node sofaNode  = roomNode.CreateChildNode("sofa",         new Box(3, 1, 1));
Node tableNode = roomNode.CreateChildNode("coffee_table", new Box(2, 0.5, 1));

Verplaatsen roomNode transformeert al het meubilair samen omdat de kinderen het erven Transform.

Zichtbaarheid en exportuitsluiting beheren

Knopen kunnen verborgen of uitgesloten worden van export zonder uit de hiërarchie te worden verwijderd:

Node ground = scene.RootNode.CreateChildNode("ground_plane", new Box(100, 0.1, 100));
ground.Visible = false;       // hidden in viewport / renderer

Node helperNode = scene.RootNode.CreateChildNode("debug_arrow", new Box());
helperNode.Excluded = true;   // omitted from all export operations

Visible = false is een weergavehint. Excluded = true voorkomt dat de node verschijnt in geëxporteerde bestanden, ongeacht het formaat.

Meerdere entiteiten aan één knoop koppelen

Een knoop heeft een primaire entiteit (Entity eigenschap), maar kan extra entiteiten bevatten via AddEntity(). Dit is handig wanneer verschillende mesh‑onderdelen een enkele transformatie delen:

var bodyMesh  = new Mesh("body");
var wheelMesh = new Mesh("wheel");

Node carNode = scene.RootNode.CreateChildNode("car");
carNode.AddEntity(bodyMesh);
carNode.AddEntity(wheelMesh);

// Retrieve all entities on this node
foreach (Entity ent in carNode.Entities)
    Console.WriteLine(ent.GetType().Name + ": " + ent.Name);

Knopen samenvoegen

Merge() verplaatst alle kinderen, entiteiten en materialen van een bronknoop naar de doelknoop. De bronknoop blijft leeg:

Node lod0 = scene.RootNode.CreateChildNode("lod0");
lod0.CreateChildNode("mesh_high", new Box(1, 1, 1));

Node lod1 = scene.RootNode.CreateChildNode("lod1");
lod1.CreateChildNode("mesh_low", new Box(1, 1, 1));

// 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 elke knoop met behulp van zijn Transform
Primaire Geometrie Maken — gebruik Box, Sphere, en Cylinder als scène‑entiteiten
Meshes Maken en Werken met Meshes — bouw polygonale geometrie en koppel deze aan knopen

API‑snelreferentie

Lid	Beschrijving
`scene.RootNode`	Wortel van de scènetboom; altijd aanwezig na `new Scene()`
`node.CreateChildNode(name)`	Maak een benoemde child node zonder entiteit
`node.CreateChildNode(name, entity)`	Maak een benoemde child node met een entiteit
`node.CreateChildNode(name, entity, material)`	Maak een benoemde child node 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.ChildNodes`	`IList<Node>` van alle directe kinderen
`node.Accept(visitor)`	Doorloop dit knooppunt en alle afstammelingen in diepte‑eerste volgorde
`node.AddEntity(entity)`	Koppel een extra entiteit aan het knooppunt
`node.Entities`	`IList<Entity>` van alle entiteiten op dit knooppunt
`node.Visible`	Toon of verberg het knooppunt
`node.Excluded`	Neem het knooppunt op in of sluit het uit bij export
`node.Merge(other)`	Verplaats alle kinderen en entiteiten van `other` naar dit knooppunt
`new Group(name)`	Container‑entiteit voor het logisch groeperen van kindknooppunten