Arbejde med scenegrafen

Hver 3D-scene i Aspose.3D for .NET er organiseret som et træ af Node objekter. Scene.RootNode er roden af dette træ, og hvert stykke geometri, materiale og transformation lever under den som et barn eller efterkommer.

Oprettelse af scenen og adgang til rotnoden

Scene initialiseres automatisk med en rotnode ved navn "RootNode":

using Aspose.ThreeD;

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

Tilføjelse af underknuder

Kald CreateChildNode() på en hvilken som helst node for at tilføje et barn. Metoden har tre almindeligt anvendte 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);

For at vedhæfte en node, der er konstrueret separat, brug AddChildNode():

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

Forespørgsel på underknuder

Find en direkte undernode efter navn eller indeks, eller iterer over alle direkte underknuder:

// 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øger kun direkte børn, ikke hele undertræet. Brug en rekursiv hjælper eller Accept() for at søge i hele træet.

Gennemløb af hele træet

For en fuld dybde‑først gennemgang, iterer 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);

For tidlig‑afslutning traversal, node.Accept(NodeVisitor) er tilgængelig og kalder besøgeren på hver efterkommer, indtil besøgeren returnerer false.

Brug af Group til at organisere relaterede objekter

Group er en container‑enhed, der logisk organiserer noder uden at tilføje geometri. Vedhæft den til en node, hvis børn repræsenterer en logisk enhed:

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

Flytning roomNode transformerer al møbler sammen, fordi børnene arver dens Transform.

Styring af synlighed og eksklusion ved eksport

Noder kan skjules eller udelukkes fra eksport uden at blive fjernet fra hierarkiet:

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 er et visningshint. Excluded = true forhindrer noden i at vises i eksporterede filer uanset format.

Tilknytning af flere entiteter til én node

En node har en primær entitet (Entity egenskab), men kan indeholde yderligere entiteter gennem AddEntity(). Dette er nyttigt, når forskellige mesh‑stykker deler en enkelt transformation:

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

Fletning af noder

Merge() flytter alle børn, entiteter og materialer fra en kilde‑node til mål‑noden. Kilde‑noden efterlades 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æste trin

Anvendelse af transformationer — positionere, rotere og skalere enhver node ved hjælp af dens Transform
Oprettelse af primitive geometrier — brug Box, Sphere, og Cylinder som scene‑entiteter
Oprettelse og arbejde med mesh‑objekter — byg polygon‑geometri og tilknyt den til noder

API‑hurtigreference

Medlem	Beskrivelse
`scene.RootNode`	Rod af scenetræet; altid til stede efter `new Scene()`
`node.CreateChildNode(name)`	Opret en navngivet undernode uden enhed
`node.CreateChildNode(name, entity)`	Opret en navngivet undernode med en enhed
`node.CreateChildNode(name, entity, material)`	Opret en navngivet undernode med enhed og materiale
`node.AddChildNode(node)`	Vedhæft en separat konstrueret `Node`
`node.GetChild(name)`	Find et direkte barn efter navn; returnerer `null` hvis ikke fundet
`node.GetChild(index)`	Hent det direkte barn ved et givet indeks
`node.ChildNodes`	`IList<Node>` af alle direkte børn
`node.Accept(visitor)`	Gå gennem denne node og alle efterkommere i dybde‑først rækkefølge
`node.AddEntity(entity)`	Vedhæft en ekstra entitet til noden
`node.Entities`	`IList<Entity>` af alle entiteter på denne node
`node.Visible`	Vis eller skjul noden
`node.Excluded`	Inkluder eller ekskluder noden fra eksport
`node.Merge(other)`	Flyt alle børn og entiteter fra `other` ind i denne node
`new Group(name)`	Container‑entitet til logisk gruppering af underordnede noder