Fonctionnalités clés de Aspose.3D FOSS pour Java

Dans le article d’introduction, nous avons couvert ce qu’est Aspose.3D FOSS pour Java et comment commencer. Cet article approfondit les fonctionnalités clés qui composent la bibliothèque, avec des exemples de code pour chaque domaine.

Tous les exemples supposent l’import suivant :

import com.aspose.threed.*;

Et la dépendance Maven :

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-3d-foss</artifactId>
    <version>26.1.0</version>
</dependency>

API du graphe de scène

Le graphe de scène est le fondement de Aspose.3D FOSS pour Java. Chaque modèle 3D – qu’il soit chargé depuis un fichier ou construit programmatique – est représenté comme un arbre de nœuds enraciné dans un Scene objet.

Scène

La Scene classe est le point d’entrée pour toutes les opérations. Vous pouvez créer une scène vide ou en charger une depuis un fichier :

// Empty scene
Scene scene = new Scene();

// Load from file
Scene loaded = Scene.fromFile("model.obj");

// Load with explicit options
Scene fromStl = Scene.fromFile("part.stl", new StlLoadOptions());

La racine de l’arbre de nœuds est accessible via getRootNode().

Nœud

Un Node représente une position nommée dans l’arbre de scène. Les nœuds peuvent avoir des enfants, formant une hiérarchie. Chaque nœud possède un local Transform et un calculé GlobalTransform.

Scene scene = new Scene();

// Create a child node under the root
Node box = scene.getRootNode().createChildNode("Box");

// Create a nested hierarchy
Node arm = scene.getRootNode().createChildNode("Arm");
Node hand = arm.createChildNode("Hand");
Node finger = hand.createChildNode("Finger");

Vous pouvez également construire des nœuds de façon indépendante et les attacher plus tard :

Node standalone = new Node("Standalone");
scene.getRootNode().getChildNodes().add(standalone);

Entity et Mesh

Un Entity est une classe de base abstraite pour tout ce qui peut être attaché à un nœud – géométrie, caméras et lumières. Le type d’entité le plus courant est Mesh, qui contient la géométrie polygonale (sommets, faces et normales).

Scene scene = Scene.fromFile("cube.obj");

// Traverse nodes and inspect entities
for (Node child : scene.getRootNode().getChildNodes()) {
    Entity entity = child.getEntity();
    if (entity instanceof Mesh) {
        Mesh mesh = (Mesh) entity;
        System.out.println("Node: " + child.getName());
        System.out.println("  Vertices: " + mesh.getControlPoints().size());
    }
}

Caméra

Les caméras sont des entités qui s’attachent aux nœuds :

Scene scene = new Scene();

Node cameraNode = scene.getRootNode().createChildNode("MainCamera");
// Camera entity can be assigned to the node

Les définitions de caméra sont conservées lors de l’exportation vers des formats qui les prennent en charge (comme glTF).

Note : Le Light classe n’est pas disponible dans l’édition Java. Les données d’éclairage de la scène provenant des fichiers importés sont stockées comme génériques Entity objets.

Chargement et sauvegarde indépendants du format

L’un des points forts de la bibliothèque est que le graphe de scène est indépendant du format. Vous chargez depuis n’importe quel format pris en charge, manipulez la scène via une API unique, puis enregistrez dans n’importe quel format pris en charge.

// Load OBJ, save as glTF
Scene scene = Scene.fromFile("input.obj");
scene.save("output.gltf");

// Load FBX, save as STL (FBX is import only)
Scene scene2 = Scene.fromFile("character.fbx");
scene2.save("character.stl");

// Load STL, save as GLB
Scene scene3 = Scene.fromFile("part.stl", new StlLoadOptions());
GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);
scene3.save("part.glb", opts);

Le format est déterminé par l’extension du fichier. Vous pouvez également fournir des options d’enregistrement explicites pour contrôler la sortie :

GltfSaveOptions opts = new GltfSaveOptions();
opts.setFlipCoordinateSystem(true);
opts.setPrettyPrint(true);

scene.save("output.gltf", opts);

Matériaux

Aspose.3D FOSS pour Java fournit un modèle de matériau PBR (Physically Based Rendering) via PbrMaterial. C’est la seule classe de matériau concrète dans l’édition Java.

PbrMaterial

Un matériau de rendu physiquement basé qui utilise les paramètres d’albédo, de métal et de rugosité. C’est le modèle de matériau standard pour glTF et les moteurs temps réel modernes.

PbrMaterial pbr = new PbrMaterial();
pbr.setAlbedo(new Vector4(0.8, 0.2, 0.2, 1.0)); // Red-ish base color
pbr.setMetallicFactor(0.0);  // Non-metallic
pbr.setRoughnessFactor(0.5); // Medium roughness

La préservation des matériaux entre les formats dépend des capacités du format cible. Les matériaux PBR se mappent naturellement vers la sortie glTF et GLB.

Transform et Spatial

Chaque Node dans le graphe de scène possède un Transform qui définit sa position, sa rotation et son échelle par rapport à son parent.

Transform local

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("TestNode");

Transform t = node.getTransform();
t.setTranslation(1, 2, 3);       // Position
t.setScale(2, 2, 2);             // Uniform scale
t.setEulerAngles(0, 45, 0);      // Euler rotation in degrees

Transform global

Le GlobalTransform est la transformation en espace mondial calculée, en tenant compte de toute la chaîne de parents. Elle est en lecture seule et se met à jour automatiquement.

Node parent = scene.getRootNode().createChildNode("Parent");
parent.getTransform().setTranslation(10, 0, 0);

Node child = parent.createChildNode("Child");
child.getTransform().setTranslation(5, 0, 0);

// Child's global position is (15, 0, 0)
GlobalTransform global = child.getGlobalTransform();

Cet héritage de transform parent-enfant suit le modèle standard de graphe de scène utilisé par les moteurs 3D et les outils DCC.

Utilitaires Mathématiques

La bibliothèque inclut des types mathématiques de base pour les opérations 3D.

Vector3

Un vecteur à trois composantes utilisé pour les positions, les directions, les normales et les couleurs.

Vector3 a = new Vector3(1, 0, 0);
Vector3 b = new Vector3(0, 1, 0);

// Addition
Vector3 sum = Vector3.add(a, b); // (1, 1, 0)

Matrix4

Une matrice de transformation 4x4 permettant de combiner la translation, la rotation et l’échelle en une seule opération.

Matrix4 mat = new Matrix4();
// Matrix4 is used internally by transforms
// and can be retrieved from GlobalTransform

Quaternion

Une représentation de rotation qui évite le gimbal lock et s’interpole de manière fluide. Les quaternions sont utilisés en interne par le système de transformation.

BoundingBox

Une boîte englobante alignée sur les axes pour les requêtes spatiales, les vérifications de collisions et l’analyse de scène.

BoundingBox bbox = new BoundingBox();
// BoundingBox can be computed from mesh geometry

Limitations connues

Il convient de noter que Scene.render() est non pris en charge dans l’édition FOSS. L’appeler déclenchera une UnsupportedOperationException. La bibliothèque est conçue pour le traitement 3D basé sur des fichiers – chargement, transformation et sauvegarde – plutôt que le rendu en temps réel.

Résumé

Les fonctionnalités clés de Aspose.3D FOSS pour Java se décomposent en cinq domaines :

Dans le prochain article, nous parcourrons des tutoriels pratiques format par format couvrant OBJ, STL, glTF et FBX avec des options détaillées de chargement et d’enregistrement.