Arbeide med scenegrafen

Hver 3D-scene i Aspose.3D for .NET er organisert som et tre av Node objekter. Scene.RootNode er roten i det treet, og hver del av geometri, materiale og transformasjon lever under den som et barn eller en etterkommer.

Opprette scenen og få tilgang til rotnoden

Scene initialiseres automatisk med en rotnode kalt "RootNode":

using Aspose.ThreeD;

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

Legge til undernoder

Kall CreateChildNode() på en hvilken som helst node for å legge til et barn. Metoden har tre ofte brukte overbelastninger:

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 å feste en node som er konstruert separat, bruk AddChildNode():

var 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)
    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 kun direkte barn, ikke hele deltreet. Bruk en rekursiv hjelpefunksjon eller Accept() for å søke i hele treet.

Traversere hele treet

For en full dybde-først-gjennomgang, 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-avsluttende traversering, node.Accept(NodeVisitor) er tilgjengelig og kaller besøkerfunksjonen på hver etterkommer til besøkerfunksjonen returnerer false.

Bruke Group for å organisere relaterte objekter

Group er en beholderenhet som logisk organiserer noder uten å legge til geometri. Fest den til en node hvis barn representerer 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));

Flytting roomNode transformerer alle møbler sammen fordi barna arver dens Transform.

Styre synlighet og ekskludering ved eksport

Noder kan skjules eller ekskluderes fra eksport uten å bli 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 visningstips. Excluded = true hindrer at noden vises i eksporterte filer uavhengig av format.

Knytte flere enheter til én node

En node har en primær entitet (Entity egenskap), men kan holde flere entiteter gjennom AddEntity(). Dette er nyttig når ulike mesh-deler deler en enkelt transformasjon:

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

Slå sammen noder

Merge() flytter alle barn, entiteter og materialer fra en kilde-node til mål-noden. Kilde-noden blir stående 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

Neste steg

Bruke Transformasjoner — posisjonere, rotere og skalere enhver node ved hjelp av dens Transform
Opprette Primitiv Geometri — bruk Box, Sphere, og Cylinder som scene-entiteter
Opprette og Arbeide med Mesh-er — bygg polygongeometri og fest den til noder

API‑hurtigreferanse

Medlem	Beskrivelse
`scene.RootNode`	Roten av scenetreet; alltid tilstede etter `new Scene()`
`node.CreateChildNode(name)`	Opprett en navngitt barnenode uten enhet
`node.CreateChildNode(name, entity)`	Opprett en navngitt barnenode med en enhet
`node.CreateChildNode(name, entity, material)`	Opprett en navngitt barnenode med enhet og materiale
`node.AddChildNode(node)`	Legg ved 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.ChildNodes`	`IList<Node>` av alle direkte barn
`node.Accept(visitor)`	Gå gjennom denne noden og alle etterkommere i dybde‑først rekkefølge
`node.AddEntity(entity)`	Legg til en ekstra enhet på noden
`node.Entities`	`IList<Entity>` av alle enheter på denne noden
`node.Visible`	Vis eller skjul noden
`node.Excluded`	Inkluder eller ekskluder noden fra eksport
`node.Merge(other)`	Flytt alle barn og enheter fra `other` inn i denne noden
`new Group(name)`	Container entity for logisk gruppering av barnenoder