Travailler avec les formats de fichiers 3D dans Java en utilisant Aspose.3D FOSS

Aspose.3D FOSS pour Java prend en charge cinq formats de fichiers 3D : OBJ, STL, glTF, GLB, et FBX (importation uniquement).

Tous les exemples utilisent le com.aspose.threed.* package :

import com.aspose.threed.*;

Dépendance Maven :

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

Paysage des formats

Avant de plonger, voici un aperçu rapide des quatre formats pris en charge et de leurs cas d’utilisation typiques.

OBJ, STL, glTF et GLB prennent en charge à la fois l’importation et l’exportation. FBX est pris en charge pour importation uniquement. GLB (binary glTF) est produit via GltfSaveOptions avec setContentType(FileContentType.BINARY).

OBJ : Wavefront Object

OBJ est l’un des formats de maillage 3D les plus largement pris en charge. Il stocke la géométrie en texte brut, avec un .mtl fichier compagnon pour les matériaux.

Chargement de fichiers OBJ

L’approche la plus simple consiste à passer le chemin du fichier directement :

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

Pour plus de contrôle, utilisez ObjLoadOptions:

ObjLoadOptions opts = new ObjLoadOptions();
Scene scene = Scene.fromFile("model.obj", opts);

Lorsque le fichier OBJ référence un fichier MTL (via un mtllib directive), la bibliothèque tentera de charger automatiquement les définitions de matériaux depuis celui‑ci. Le fichier MTL doit se trouver dans le même répertoire que le fichier OBJ ou au chemin indiqué dans la directive.

Enregistrement au format OBJ

Scene scene = Scene.fromFile("input.fbx");
scene.save("output.obj");

Cas d’utilisation d’OBJ

• Échange de données de maillage entre différents outils 3D.
• Importation de modèles à partir de bibliothèques d’actifs qui distribuent au format OBJ.
• Inspection rapide de la géométrie sans hiérarchies de scène complexes.

STL : Stéréolithographie

STL est le format standard pour l’impression 3D. Il représente une géométrie triangulée brute sans matériaux, couleurs ou hiérarchie de scène. Les fichiers STL existent en deux variantes : ASCII (lisible par l’homme) et binaire (compacte).

Chargement de fichiers STL

// Simple load
Scene scene = Scene.fromFile("part.stl");

// With explicit options
StlLoadOptions opts = new StlLoadOptions();
Scene scene = Scene.fromFile("part.stl", opts);

Enregistrement au format STL

Scene scene = Scene.fromFile("model.obj");
scene.save("output.stl");

Pour contrôler la sortie, utilisez StlSaveOptions:

StlSaveOptions opts = new StlSaveOptions();
scene.save("output.stl", opts);

Considérations concernant le STL

• STL ne stocke que la géométrie triangulaire. Les matériaux, textures et la hiérarchie de scène ne sont pas pris en charge et sont supprimés lors de l’exportation.
• L’exportation STL ne trianguler automatiquement. Le STL binaire n’écrit que les trois premiers sommets de chaque face polygonale ; les faces quadrangulaires et n‑gon sont silencieusement tronquées. Le STL ASCII écrit tous les indices de sommets par face, produisant une sortie malformée pour les faces non triangulaires. Utilisez toujours des maillages pré‑triangulés (faces entièrement triangulaires) lors de l’exportation vers STL.
• Le STL binaire est nettement plus petit que le STL ASCII pour les modèles volumineux.
• STL est le format de choix lorsque la cible est une imprimante 3D ou un logiciel de découpe.

glTF : GL Transmission Format

glTF est un format moderne conçu pour la transmission et le chargement efficaces de contenu 3D, en particulier sur le web et dans les applications en temps réel. Il prend en charge les matériaux PBR, les hiérarchies de scène et les animations.

Chargement de fichiers glTF

Scene scene = Scene.fromFile("scene.gltf");

// With options
GltfLoadOptions opts = new GltfLoadOptions();
Scene scene = Scene.fromFile("scene.gltf", opts);

Enregistrement au format glTF

L’enregistrement de base utilise l’extension de fichier pour déterminer le format :

scene.save("output.gltf");

Pour un contrôle détaillé, utilisez GltfSaveOptions:

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

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

Détails de GltfSaveOptions

Cas d’utilisation de glTF

• Visionneuses 3D basées sur le Web (three.js, Babylon.js).
• Applications en temps réel et moteurs de jeu.
• Préserver les définitions de matériaux PBR entre les outils.

FBX : Filmbox (Importation uniquement)

FBX est un format propriétaire d’Autodesk largement utilisé dans le développement de jeux et la création de contenu numérique. Aspose.3D FOSS pour Java prend en charge FBX pour import uniquement — l’exportation vers FBX n’est pas disponible.

Uniquement FBX binaire. L’importateur FBX ne lit que les fichiers FBX binaires. Fournir un fichier FBX ASCII déclenche ImportException("ASCII FBX format not yet supported - only binary FBX is supported"). La hiérarchie des nœuds et l’extraction des matériaux depuis le FBX ne sont pas entièrement vérifiées ; les scènes FBX complexes peuvent ne pas se charger complètement. Les animations et le rigging ne sont pas implémentés.

Chargement de fichiers FBX

Scene scene = Scene.fromFile("character.fbx");

// With options
FbxLoadOptions opts = new FbxLoadOptions();
Scene scene = Scene.fromFile("character.fbx", opts);

Conversion de FBX vers d’autres formats

Étant donné que l’exportation FBX n’est pas prise en charge, convertissez les scènes FBX importées en glTF, GLB, OBJ ou STL :

Scene scene = Scene.fromFile("character.fbx");

// Save as GLB
GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);
scene.save("character.glb", opts);

Cas d’utilisation de FBX

• Importation d’actifs de maillage statique depuis les outils Autodesk (Maya, 3ds Max) et conversion vers d’autres formats.
• Chargement de géométrie FBX binaire et réexportation vers glTF/GLB, OBJ ou STL.

Conversion par lots

Un flux de travail courant consiste à convertir un répertoire complet de fichiers d’un format à un autre. Voici un modèle pour la conversion par lots :

import com.aspose.threed.*;
import java.io.File;

public class BatchConvert {
    public static void main(String[] args) throws Exception {
        File inputDir = new File("models/obj");
        File outputDir = new File("models/gltf");
        outputDir.mkdirs();

        GltfSaveOptions saveOpts = new GltfSaveOptions();
        saveOpts.setPrettyPrint(true);

        File[] objFiles = inputDir.listFiles(
            (dir, name) -> name.toLowerCase().endsWith(".obj")
        );

        if (objFiles == null) return;

        for (File objFile : objFiles) {
            String baseName = objFile.getName()
                .replaceFirst("\\.obj$", "");

            Scene scene = Scene.fromFile(objFile.getAbsolutePath());
            String outPath = new File(outputDir, baseName + ".gltf")
                .getAbsolutePath();

            scene.save(outPath, saveOpts);
            System.out.println("Converted: " + objFile.getName()
                + " -> " + baseName + ".gltf");
        }
    }
}

Cela charge chaque .obj fichier dans un répertoire, convertit chacun en glTF avec une sortie formatée de manière lisible, et enregistre les résultats. Vous pouvez adapter ce modèle à toute combinaison de formats source et cible.

Référence de conversion inter‑formats

Le tableau suivant montre à quoi s’attendre lors de la conversion entre formats.

Directives générales de conversion

• Géométrie est généralement conservé entre les paires de formats, avec une exception importante : lors de l’exportation vers STL, les maillages doivent être composés uniquement de faces triangulaires. Le STL binaire tronque silencieusement les faces quadrangulaires et n-gon à leurs trois premiers sommets ; le STL ASCII génère une sortie malformée pour les faces non triangulaires.
• Matériaux survivent le mieux entre les scènes importées glTF et FBX qui incluent des données de matériaux. La conversion en STL supprime toujours les matériaux. La conversion en OBJ simplifie les matériaux au modèle MTL de base.
• Hiérarchie de la scène est conservée entre les fichiers au format glTF. OBJ et STL produisent des structures plates. La hiérarchie FBX et l’extraction des matériaux ne sont pas entièrement vérifiées dans cette version.

Mettre tout ensemble

Voici un exemple complet qui charge un fichier OBJ, inspecte ses nœuds, et exporte à la fois en glTF et en GLB :

import com.aspose.threed.*;

public class FormatWorkflow {
    public static void main(String[] args) throws Exception {
        // Load
        Scene scene = Scene.fromFile("input.obj");

        // Inspect
        System.out.println("Nodes in scene:");
        for (Node child : scene.getRootNode().getChildNodes()) {
            System.out.println("  " + child.getName());
            Transform t = child.getTransform();
            System.out.println("    Translation: "
                + t.getTranslation());
        }

        // Export to glTF with options
        GltfSaveOptions gltfOpts = new GltfSaveOptions();
        gltfOpts.setPrettyPrint(true);
        scene.save("output.gltf", gltfOpts);

        // Export to GLB (binary glTF)
        GltfSaveOptions glbOpts = new GltfSaveOptions();
        glbOpts.setContentType(FileContentType.BINARY);
        scene.save("output.glb", glbOpts);

        System.out.println("Export complete.");
    }
}

Résumé

Aspose.3D FOSS pour Java vous offre une API cohérente à travers plusieurs formats. Les points clés :

• OBJ – échange simple de maillages avec des matériaux de base.
• STL – format uniquement géométrique pour les pipelines d’impression 3D.
• glTF / GLB – format moderne compatible PBR pour le web et l’utilisation en temps réel. Utilisez GltfSaveOptions avec setContentType(FileContentType.BINARY) pour la sortie GLB.
• FBX – importation uniquement ; format riche pour charger des actifs depuis les moteurs de jeu et les outils DCC.

Utilisez les classes d’options de chargement et d’enregistrement spécifiques au format (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptions) lorsque vous avez besoin d’un contrôle granulaire sur le processus d’importation ou d’exportation.

Pour plus de détails, consultez le Aspose.3D documentation ou parcourez le code source sur GitHub.