Travailler avec le scène graphique

Chaque scène 3D dans Aspose.3D pour Java est organisée comme un arbre de Node objets . Scene Il y a une seule racine - getRootNode() - et chaque morceau de géométrie, matériel, et transformation des vies sous cette racine comme un enfant ou un node descendant.

Créer la scène et accéder au node racine

Scene Initialiser automatiquement avec un node de racine nommé "RootNode":

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

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

Ajouter des noyaux pour enfants

Appel à createChildNode() sur nœuds pour ajouter un enfant. La méthode a trois surcharges couramment utilisés:

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 ajouter un node qui a été construit séparément, utilisez addChildNode():

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

Les noyaux d’enfant

Trouvez un enfant direct par nom ou par index, ou iterez 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) Seuls les recherches Les enfants directs,pas le tout, c’est la mémoire. - Je vous rappelle que accept() Il n’y a que le nom de « noyau » ; iterate. getChildNodes() Il faut chercher à nouveau l’ensemble de l’arbre.

Traverser l’arbre plein

node.accept(NodeVisitor) visite seulement le node appelé - il ne se récurs pas dans les enfants. Pour traverser l’arbre plein, itérate getChildNodes() Récupérateur : le visiteur revient true Pour continuer ou false 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 Il est une interface à méthode unique, donc il accepte un lambda dans Java 8+.

Contrôle de la visibilité et exclusion des exportations

Les nœuds peuvent être cachés ou exclu d’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) C’est un indicateur de l’affichage. setExcluded(true) empêche le node de apparaître dans les fichiers exportés, quel que soit le format.

L’association de plusieurs entités à un seul node

Un node a une primaire L’entité (getEntity() / setEntity()( ) mais peut tenir des entités supplémentaires à travers addEntity().Ceci est utile lorsque différents morceaux de mesh partagent une transformation unique:

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

Mélangez les nôtres

merge() Il déplacera tous les enfants, entités et matériaux d’un node source vers le nodo cible.:

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

API de référence rapide

Membre	Description
`scene.getRootNode()`	La racine de l’arbre scénariste ; toujours présente après `new Scene()`
`node.createChildNode(name)`	Créer un noyau d’enfant avec aucune entité
`node.createChildNode(name, entity)`	Créer un noyau d’enfant avec une entité
`node.createChildNode(name, entity, material)`	Créer un noyau d’enfant avec entité et matériel
`node.addChildNode(node)`	Un bâtiment séparément construit `Node`
`node.getChild(name)`	Trouvez un enfant direct par nom ; retour `null` Si on ne trouve pas
`node.getChild(index)`	Obtenez l’enfant direct à un index donné
`node.getChildNodes()`	`List<Node>` Tous les enfants directs
`node.accept(visitor)`	Visitez seulement ce node (ne pas se réciter aux enfants)
`node.addEntity(entity)`	Ajouter une entité supplémentaire au node
`node.getEntities()`	`List<Entity>` de toutes les entités sur ce node
`node.setVisible(bool)`	Afficher ou cacher le node
`node.setExcluded(bool)`	Inclure ou exclu le node de l’exportation
`node.merge(other)`	Mettre tous les enfants et entités à partir de `other` Dans ce node