Travailler avec le graphe de scène

Chaque scène 3D dans Aspose.3D pour Java est organisée sous forme d’arbre de Node objets. Scene fournit une racine unique — getRootNode() — et chaque morceau de géométrie, de matériau et de transformation vit sous cette racine en tant que nœud enfant ou descendant.

Création de la scène et accès au nœud racine

Scene s’initialise automatiquement avec un nœud racine nommé "RootNode":

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

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

Ajout de nœuds enfants

Call createChildNode() sur n’importe quel nœud pour ajouter un enfant. La méthode possède trois surcharges couramment utilisées :

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

Pour attacher un nœud qui a été construit séparément, utilisez addChildNode():

Node detached = new Node("standalone");
root.addChildNode(detached);

Interrogation des nœuds enfants

Trouvez un enfant direct par nom ou par indice, ou parcourez tous les enfants directs :

// 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) recherche uniquement les enfants directs, pas l’arborescence complète. Utilisez accept() pour rechercher tout l’arbre.

Parcourir l’arbre complet

node.accept(NodeVisitor) parcourt un nœud et tous ses descendants en ordre profondeur d’abord. Le visiteur renvoie true pour continuer ou false pour arrêter tôt :

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 est une interface à méthode unique, donc elle accepte une lambda dans Java 8+.

Contrôle de la visibilité et exclusion à l’exportation

Les nœuds peuvent être masqués ou exclus de l’exportation sans être retirés de la hiérarchie :

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) est un indice d’affichage. setExcluded(true) empêche le nœud d’apparaître dans les fichiers exportés, quel que soit le format.

Attacher plusieurs entités à un même nœud

Un nœud possède un principal entité (getEntity() / setEntity()), mais peut contenir des entités supplémentaires via addEntity(). Ceci est utile lorsque différentes pièces de maillage partagent une même transformation :

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

Fusion de nœuds

merge() déplace tous les enfants, entités et matériaux d’un nœud source vers le nœud cible. Le nœud source reste vide :

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

Étapes suivantes

Application des transformations — positionner, faire pivoter et mettre à l’échelle n’importe quel nœud à l’aide de son Transform
Création et manipulation de maillages — créer une géométrie polygonale et l’attacher aux nœuds

Référence rapide de l’API

Membre	Description
`scene.getRootNode()`	Racine de l’arbre de scène ; toujours présent après `new Scene()`
`node.createChildNode(name)`	Créer un nœud enfant nommé sans entité
`node.createChildNode(name, entity)`	Créer un nœud enfant nommé avec une entité
`node.createChildNode(name, entity, material)`	Créer un nœud enfant nommé avec entity et material
`node.addChildNode(node)`	Attacher un séparément construit `Node`
`node.getChild(name)`	Trouver un enfant direct par nom ; renvoie `null` si non trouvé
`node.getChild(index)`	Obtenir l’enfant direct à un indice donné
`node.getChildNodes()`	`List<Node>` de tous les enfants directs
`node.accept(visitor)`	Parcourir ce nœud et tous ses descendants en profondeur
`node.addEntity(entity)`	Attacher une entity supplémentaire au node
`node.getEntities()`	`List<Entity>` de toutes les entities sur ce node
`node.setVisible(bool)`	Afficher ou masquer le node
`node.setExcluded(bool)`	Inclure ou exclure le node de l’exportation
`node.merge(other)`	Déplacez tous les enfants et entités depuis `other` dans ce nœud