Práca s grafom scény

Každá 3D scéna v Aspose.3D pre .NET je organizovaná ako strom Node objektov. Scene.RootNode je koreňom tohto stromu a každý kus geometrie, materiálu a transformácie žije pod ním ako dieťa alebo potomok.

Vytváranie scény a prístup ku koreňovému uzlu

Scene inicializuje sa automaticky s koreňovým uzlom s názvom "RootNode":

using Aspose.ThreeD;

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

Pridávanie podriadených uzlov

Call CreateChildNode() na ľubovoľnom uzle na pridanie dieťaťa. Metóda má tri bežne používané preťaženia:

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

Na pripojenie uzla vytvoreného samostatne použite AddChildNode():

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

Dotazovanie podriadených uzlov

Nájdite priamy podriadený uzol podľa názvu alebo indexu, alebo prechádzajte všetkých priamych podriadených uzlov:

// 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) hľadá iba priame deti, nie celý podstrom. Použite rekurzívnu pomocnú funkciu alebo Accept() na prehľadanie celého stromu.

Prechádzanie celého stromu

Pre úplnú prehliadku do hĺbky iterujte ChildNodes rekurzívne:

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

Pre prehliadku s predčasným ukončením, node.Accept(NodeVisitor) je k dispozícii a volá návštevníka na každého potomka, kým návštevník nevráti false.

Použitie Group na organizovanie súvisiacich objektov

Group je kontajnerová entita, ktorá logicky organizuje uzly bez pridania geometrie. Pripojte ju k uzlu, ktorého potomkovia predstavujú logickú jednotku:

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

Presúvanie roomNode transformuje všetok nábytok spolu, pretože deti zdedia jeho Transform.

Riadenie viditeľnosti a vylúčenie z exportu

Uzly môžu byť skryté alebo vylúčené z exportu bez toho, aby boli odstránené z hierarchie:

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 je nápoveda na zobrazenie. Excluded = true zabraňuje uzlu objaviť sa v exportovaných súboroch bez ohľadu na formát.

Pripojenie viacerých entít k jednému uzlu

Uzol má primárny entitu (Entity vlastnosť), ale môže obsahovať ďalšie entity prostredníctvom AddEntity(). Toto je užitočné, keď rôzne časti siete zdieľajú jeden 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);

Zlučovanie uzlov

Merge() presunie všetky podriadené objekty, entity a materiály zo zdrojového uzla do cieľového uzla. Zdrojový uzol zostane prázdny:

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

Ďalšie kroky

Aplikovanie transformácií — položenie, otáčanie a škálovanie akéhokoľvek uzla pomocou jeho Transform
Vytváranie primitívnej geometrie — použite Box, Sphere, a Cylinder ako entity scény
Vytváranie a práca so sieťami — zostavte polygonálnu geometriu a pripojte ju k uzlom

Rýchla referencia API

Člen	Popis
`scene.RootNode`	Koreň stromu scény; vždy prítomný po `new Scene()`
`node.CreateChildNode(name)`	Vytvoriť pomenovaný podriadený uzol bez entity
`node.CreateChildNode(name, entity)`	Vytvoriť pomenovaný podriadený uzol s entitou
`node.CreateChildNode(name, entity, material)`	Vytvoriť pomenovaný podriadený uzol s entitou a materiálom
`node.AddChildNode(node)`	Pripojiť samostatne zostavený `Node`
`node.GetChild(name)`	Nájsť priamy podriadený podľa názvu; vracia `null` ak sa nenašiel
`node.GetChild(index)`	Získať priamy podriadený na zadanom indexe
`node.ChildNodes`	`IList<Node>` všetkých priamych podriadených
`node.Accept(visitor)`	Prejsť tento uzol a všetky podriadené uzly do hĺbky
`node.AddEntity(entity)`	Pripojiť ďalšiu entitu k uzlu
`node.Entities`	`IList<Entity>` všetkých entít na tomto uzle
`node.Visible`	Zobraziť alebo skryť uzol
`node.Excluded`	Zahrnúť alebo vylúčiť uzol z exportu
`node.Merge(other)`	Presunúť všetky podriadené a entity z `other` do tohto uzla
`new Group(name)`	Kontajnerová entita pre logické zoskupovanie podriadených uzlov