Arbeta med scengrafen

Varje 3D‑scen i Aspose.3D for .NET är organiserad som ett träd av Node‑objekt. Scene.RootNode är roten i det trädet och varje del av geometri, material och transformation lever under den som ett barn eller en ättling.

Skapa scenen och komma åt rotnoden

Scene initierar automatiskt med en rotnod som heter "RootNode":

using Aspose.ThreeD;

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

Lägga till barnnoder

Anropa CreateChildNode() på vilken nod som helst för att lägga till ett barn. Metoden har tre vanligt använda överlagringar:

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

För att bifoga en nod som konstruerats separat, använd AddChildNode():

var detached = new Node("standalone");
root.AddChildNode(detached);

Fråga barnnoder

Hitta ett direkt barn efter namn eller efter index, eller iterera alla direkta barn:

// 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) söker endast direkta barn, inte hela underträdet. Använd en rekursiv hjälpfunktion eller Accept() för att söka i hela trädet.

Traversera hela trädet

För en fullständig djup‑först‑genomgång, iterera ChildNodes rekursivt:

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

För tidig‑utgångsgenomgång är node.Accept(NodeVisitor) tillgänglig och anropar besökaren på varje nedärvd element tills besökaren returnerar false.

Använda grupp för att organisera relaterade objekt

Group är en behållarenhet som logiskt organiserar noder utan att lägga till geometri. Fäst den på en nod vars barn representerar en logisk enhet:

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

Att flytta roomNode omvandlar alla möbler tillsammans eftersom barnen ärver dess Transform.

Kontroll av synlighet och exportundantag

Noder kan döljas eller uteslutas från export utan att tas bort från hierarkin:

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 är en displayhint. Excluded = true förhindrar att noden visas i exporterade filer oavsett format.

Bifoga flera enheter till en nod

En nod har en primär entitet (Entity‑egenskap), men kan hålla ytterligare entiteter via AddEntity(). Detta är användbart när olika mesh‑delar delar en enda transform:

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

Sammanfoga noder

Merge() flyttar alla barn, enheter och material från en källnod till mål‑noden. Källnoden lämnas tom:

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

Nästa steg

Applicera transformationer — positionera, rotera och skala valfri nod med dess Transform
Skapa primitiv geometri — använd Box, Sphere och Cylinder som scenobjekt
Skapa och arbeta med meshar — bygg polygongeometri och fäst den på noder

API Snabbreferens

Member	Description
`scene.RootNode`	Roten av scenträdet; alltid närvarande efter `new Scene()`
`node.CreateChildNode(name)`	Skapa en namngiven barnnod utan någon entitet
`node.CreateChildNode(name, entity)`	Skapa en namngiven barnnod med en entitet
`node.CreateChildNode(name, entity, material)`	Skapa en namngiven barnnod med entitet och material
`node.AddChildNode(node)`	Fäst en separat konstruerad `Node`
`node.GetChild(name)`	Hitta ett direkt barn efter namn; returnerar `null` om det inte hittas
`node.GetChild(index)`	Hämta det direkta barnet på ett givet index
`node.ChildNodes`	`IList<Node>` av alla direkta barn
`node.Accept(visitor)`	Gå igenom denna nod och alla underordnade i djupet först
`node.AddEntity(entity)`	Fäst en ytterligare entitet till noden
`node.Entities`	`IList<Entity>` av alla entiteter på denna nod
`node.Visible`	Visa eller dölja noden
`node.Excluded`	Inkludera eller exkludera noden från export
`node.Merge(other)`	Flytta alla barn och entiteter från `other` till denna nod
`new Group(name)`	Behållarenhet för logisk gruppering av barnnoder