Bekerja dengan Graf Adegan

Setiap adegan 3D dalam Aspose.3D untuk .NET disusun sebagai pokok Node objek. Scene.RootNode adalah akar pokok itu dan setiap kepingan geometri, bahan, dan transformasi berada di bawahnya sebagai anak atau keturunan.

Mencipta Adegan dan Mengakses Nod Akar

Scene dimulakan secara automatik dengan nod akar bernama "RootNode":

using Aspose.ThreeD;

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

Menambah Nod Anak

Panggil CreateChildNode() pada mana-mana nod untuk menambah anak. Kaedah ini mempunyai tiga overload yang biasa digunakan:

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

Untuk melampirkan nod yang dibina secara berasingan, gunakan AddChildNode():

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

Menanya Nod Anak

Cari anak langsung mengikut nama atau indeks, atau ulang semua anak langsung:

// 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) hanya mencari anak langsung, bukan seluruh subpokok. Gunakan pembantu rekursif atau Accept() untuk mencari seluruh pokok.

Menerokai Pokok Penuh

Untuk penelusuran depth-first penuh, ulangi ChildNodes secara rekursif:

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

Untuk penelusuran keluar awal, node.Accept(NodeVisitor) tersedia dan memanggil pelawat pada setiap keturunan sehingga pelawat mengembalikan false.

Menggunakan Group untuk Mengatur Objek Berkaitan

Group adalah entiti kontena yang secara logik menyusun nod tanpa menambah geometri. Lampirkan ia pada nod yang anak‑anaknya mewakili unit logik:

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

Bergerak roomNode menukar semua perabot sekaligus kerana anak‑anak mewarisinya Transform.

Mengawal Kebolehlihatan dan Pengecualian Eksport

Node boleh disembunyikan atau dikecualikan daripada eksport tanpa dibuang daripada hierarki:

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 adalah petunjuk paparan. Excluded = true mencegah node daripada muncul dalam fail yang dieksport tanpa mengira format.

Menyambungkan Pelbagai Entiti kepada Satu Node

Sebuah nod mempunyai utama entiti (Entity ciri), tetapi boleh memegang entiti tambahan melalui AddEntity(). Ini berguna apabila kepingan mesh yang berbeza berkongsi satu transformasi:

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

Menggabungkan Node

Merge() memindahkan semua anak, entiti, dan bahan dari nod sumber ke nod sasaran. Nod sumber dibiarkan kosong:

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

Langkah Seterusnya

Menerapkan Transformasi — kedudukan, putar, dan skala mana-mana nod menggunakan Transform
Mencipta Geometri Primitif — gunakan Box, Sphere, dan Cylinder sebagai entiti adegan
Mencipta dan Bekerja dengan Meshes — bina geometri poligon dan lampirkan kepada nod

Rujukan Pantas API

Ahli	Deskripsi
`scene.RootNode`	Akar pokok adegan; sentiasa wujud selepas `new Scene()`
`node.CreateChildNode(name)`	Cipta nod anak bernama tanpa entiti
`node.CreateChildNode(name, entity)`	Cipta nod anak bernama dengan entiti
`node.CreateChildNode(name, entity, material)`	Cipta nod anak bernama dengan entiti dan bahan
`node.AddChildNode(node)`	Lampirkan yang dibina secara berasingan `Node`
`node.GetChild(name)`	Cari anak langsung mengikut nama; mengembalikan `null` jika tidak dijumpai
`node.GetChild(index)`	Dapatkan anak langsung pada indeks yang diberikan
`node.ChildNodes`	`IList<Node>` daripada semua anak langsung
`node.Accept(visitor)`	Lalui nod ini dan semua keturunan secara depth-first
`node.AddEntity(entity)`	Lampirkan entiti tambahan kepada nod
`node.Entities`	`IList<Entity>` daripada semua entiti pada nod ini
`node.Visible`	Tunjukkan atau sembunyikan nod
`node.Excluded`	Sertakan atau kecualikan nod daripada eksport
`node.Merge(other)`	Alih semua anak dan entiti daripada `other` ke dalam nod ini
`new Group(name)`	Entiti kontena untuk mengelompokkan nod anak secara logik