Lucrul cu graficul de scenă

Fiecare scenă 3D în Aspose.3D pentru .NET este organizată ca un arbore de Node obiecte. Scene.RootNode este rădăcina acelui arbore și fiecare bucată de geometrie, material și transformare trăiește sub el ca un copil sau descendent.

Crearea scenei și accesarea nodului rădăcină

Scene se inițializează automat cu un nod rădăcină numit "RootNode":

using Aspose.ThreeD;

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

Adăugarea nodurilor copil

Call CreateChildNode() pe orice nod pentru a adăuga un copil. Metoda are trei suprasarcini utilizate frecvent:

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

Pentru a atașa un nod construit separat, folosiți AddChildNode():

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

Interogarea nodurilor copil

Găsește un copil direct după nume sau după index, sau iterează toți copiii direcți:

// 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) caută doar copii direcți, nu subarborele complet. Utilizați un ajutor recursiv sau Accept() pentru a căuta întregul arbore.

Parcurgerea arborelui complet

Pentru o parcurgere completă în adâncime, iteraţi ChildNodes recursiv:

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

Pentru parcurgerea cu ieșire anticipată, node.Accept(NodeVisitor) este disponibil și apelează vizitatorul pe fiecare descendent până când vizitatorul returnează false.

Folosirea grupului pentru a organiza obiecte legate

Group este o entitate container care organizează logic nodurile fără a adăuga geometrie. Atașați‑o la un nod ale cărui copii reprezintă o unitate logică:

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

Mutarea roomNode transformă toate mobilierul împreună deoarece copiii moștenesc al său Transform.

Controlul vizibilității și excluderea la export

Nodurile pot fi ascunse sau excluse din export fără a fi eliminate din ierarhie:

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 este un indiciu de afișare. Excluded = true previne apariția nodului în fișierele exportate, indiferent de format.

Atașarea mai multor entități la un singur nod

Un nod are un principal entitate (Entity proprietate), dar poate conține entități suplimentare prin AddEntity(). Acest lucru este util când diferite piese de mesh împărtășesc o singură transformare:

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

Fuzionarea nodurilor

Merge() mută toți copiii, entitățile și materialele dintr-un nod sursă în nodul țintă. Nodul sursă rămâne gol:

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

Pașii următori

Aplicarea Transformărilor — poziționează, rotește și scalează orice nod folosind Transform
Crearea Geometriei Primitive — folosește Box, Sphere, și Cylinder ca entități de scenă
Crearea și Lucrul cu Mesh-uri — construiește geometria poligonului și atașeaz-o la noduri

Referință rapidă API

Membru	Descriere
`scene.RootNode`	Rădăcina arborelui de scenă; întotdeauna prezentă după `new Scene()`
`node.CreateChildNode(name)`	Creează un nod copil numit fără entitate
`node.CreateChildNode(name, entity)`	Creează un nod copil numit cu o entitate
`node.CreateChildNode(name, entity, material)`	Creează un nod copil numit cu entitate și material
`node.AddChildNode(node)`	Atașează un element construit separat `Node`
`node.GetChild(name)`	Găsește un copil direct după nume; returnează `null` dacă nu este găsit
`node.GetChild(index)`	Obține copilul direct la un index dat
`node.ChildNodes`	`IList<Node>` al tuturor copiilor direcți
`node.Accept(visitor)`	Parcurge acest nod și toți descendenții în adâncime
`node.AddEntity(entity)`	Atașează o entitate suplimentară la nod
`node.Entities`	`IList<Entity>` al tuturor entităților de pe acest nod
`node.Visible`	Afișează sau ascunde nodul
`node.Excluded`	Include sau exclude nodul din export
`node.Merge(other)`	Mută toți copiii și entitățile din `other` în acest nod
`new Group(name)`	Entitate container pentru gruparea logică a nodurilor copil