Bekerja dengan Graf Adegan

Setiap adegan 3D dalam Aspose.3D untuk Java disusun sebagai pokok bagi Node objek. Scene menyediakan satu akar — getRootNode() — dan setiap bahagian geometri, bahan, dan transformasi berada di bawah akar itu sebagai nod anak atau keturunan.

Mencipta Adegan dan Mengakses Nod Akar

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

import com.aspose.threed.Scene;
import com.aspose.threed.Node;

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

Menambah Nod Anak

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

import com.aspose.threed.*;

Scene scene = new Scene();
Node root = scene.getRootNode();

// 1. Named node with no entity — useful as a pivot or group container
Node pivot = root.createChildNode("pivot");

// 2. Named node with an entity
Mesh mesh = new Mesh("box");
mesh.getControlPoints().add(new Vector4(0, 0, 0));
mesh.getControlPoints().add(new Vector4(1, 0, 0));
mesh.getControlPoints().add(new Vector4(1, 1, 0));
mesh.getControlPoints().add(new Vector4(0, 1, 0));
mesh.createPolygon(0, 1, 2, 3);
Node meshNode = root.createChildNode("box", mesh);

// 3. Named node with entity and material
PbrMaterial mat = new PbrMaterial("red");
mat.setAlbedo(new Vector4(0.8f, 0.2f, 0.2f, 1.0f));
Node decorated = pivot.createChildNode("red_box", mesh, mat);

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

Node 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) {
    System.out.println("Found: " + found.getName());
}

// By index
Node first = root.getChild(0);

// Iterate all direct children
for (Node child : root.getChildNodes()) {
    System.out.println(child.getName());
}

getChild(String name) hanya mencari anak langsung, bukan seluruh subpokok. Gunakan accept() untuk mencari seluruh pokok.

Menerokai Pokok Penuh

node.accept(NodeVisitor) menelusuri satu nod dan semua keturunannya dalam susunan depth-first. Pelawat mengembalikan true untuk terus atau false untuk berhenti lebih awal:

import com.aspose.threed.NodeVisitor;

// Print every node name in the scene
scene.getRootNode().accept(n -> {
    System.out.println(n.getName());
    return true; // false would stop traversal
});

// Stop after finding the first node that has an entity
final Node[] found = {null};
scene.getRootNode().accept(n -> {
    if (n.getEntity() != null) {
        found[0] = n;
        return false; // stop walking
    }
    return true;
});

NodeVisitor adalah antara muka satu-kaedah, jadi ia menerima lambda dalam Java 8+.

Mengawal Kebolehlihatan dan Pengecualian Eksport

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

Node ground = root.createChildNode("ground_plane", mesh);
ground.setVisible(false);       // hidden in viewport / renderer

Node helperNode = root.createChildNode("debug_arrow", mesh);
helperNode.setExcluded(true);   // omitted from all export operations

setVisible(false) ialah petunjuk paparan. setExcluded(true) menghalang nod daripada muncul dalam fail yang dieksport tanpa mengira format.

Menyambungkan Pelbagai Entiti kepada Satu Node

Sebuah nod mempunyai utama entiti (getEntity() / setEntity()), tetapi boleh memegang entiti tambahan melalui addEntity(). Ini berguna apabila kepingan mesh yang berbeza berkongsi satu transformasi:

Mesh body  = new Mesh("body");
Mesh wheel = new Mesh("wheel");

Node carNode = root.createChildNode("car");
carNode.addEntity(body);
carNode.addEntity(wheel);

// Retrieve all entities on this node
for (Entity ent : carNode.getEntities()) {
    System.out.println(ent.getName());
}

Menggabungkan Node

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

Node lod0 = root.createChildNode("lod0");
lod0.createChildNode("mesh_high", mesh);

Node lod1 = root.createChildNode("lod1");
lod1.createChildNode("mesh_low", mesh);

// 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
Membuat dan Bekerja dengan Mesh — bina geometri poligon dan lampirkan kepada nod

Rujukan Pantas API

Ahli	Keterangan
`scene.getRootNode()`	Akar pokok adegan; sentiasa hadir 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.getChildNodes()`	`List<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.getEntities()`	`List<Entity>` daripada semua entiti pada nod ini
`node.setVisible(bool)`	Tunjukkan atau sembunyikan nod
`node.setExcluded(bool)`	Sertakan atau kecualikan nod daripada eksport
`node.merge(other)`	Alih semua anak dan entiti daripada `other` ke dalam nod ini