Présentation de Aspose.3D FOSS pour Java

Nous sommes ravis d’annoncer la disponibilité de Aspose.3D FOSS for Java – une bibliothèque gratuite et open source pour travailler avec les formats de fichiers 3D dans les applications Java. Conçue comme une solution pure Java sans dépendances natives, la bibliothèque fonctionne sur Java 21 et versions ultérieures, ce qui la rend accessible à un large éventail de projets et d’environnements.

Cet article passe en revue ce que la bibliothèque offre, comment démarrer et les étapes suivantes.

Qu’est-ce que Aspose.3D FOSS pour Java ?

Aspose.3D FOSS for Java est une bibliothèque légère de traitement de fichiers 3D publiée sous la licence MIT. Elle fournit une API de graphe de scène qui vous permet de charger, inspecter, transformer et enregistrer des modèles 3D dans plusieurs formats largement utilisés. La bibliothèque est entièrement écrite en Java et ne nécessite aucun binaire natif externe ni aucune configuration spécifique à la plateforme.

Le code source est disponible sur GitHub : https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Points clés

• Pur Java – pas de JNI, pas de bibliothèques natives, pas de restrictions de plateforme.
• Java 21+ compatible.
• licence MIT – utilisez‑le dans des projets personnels, commerciaux ou propriétaires sans restrictions.
• architecture de graphe de scène – un arbre familier de nœuds, maillages, caméras et matériaux.
• prise en charge multi‑format – lire et écrire les fichiers OBJ, STL, glTF 2.0 et GLB ; lire les fichiers FBX.

Démarrage rapide

Installation de Maven

Ajoutez la dépendance suivante à votre pom.xml:

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

Votre première conversion

Le cas d’utilisation le plus simple consiste à charger un fichier 3D dans un format et à l’enregistrer dans un autre. Voici une conversion en deux lignes de OBJ vers STL :

import com.aspose.threed.*;

public class QuickConvert {
    public static void main(String[] args) throws Exception {
        Scene scene = Scene.fromFile("cube.obj");
        scene.save("output.stl");
    }
}

Le Scene class est le point d’entrée central. Appelez Scene.fromFile() avec un chemin de fichier pour charger un model, puis appelez save() avec le chemin cible. La bibliothèque déduit le format à partir de l’extension du fichier.

Construire une scène à partir de zéro

Vous pouvez également construire des scènes de manière programmatique :

import com.aspose.threed.*;

public class BuildScene {
    public static void main(String[] args) throws Exception {
        Scene scene = new Scene();
        Node node = scene.getRootNode().createChildNode("Box");

        Transform t = node.getTransform();
        t.setTranslation(1, 2, 3);

        scene.save("scene.gltf");
    }
}

Cela crée une nouvelle scène, ajoute un nœud enfant nommé “Box” sous la racine, le positionne aux coordonnées (1, 2, 3) et exporte le résultat sous forme de fichier glTF.

Chargement avec des options spécifiques au format

Lorsque vous avez besoin d’un contrôle plus fin du processus de chargement, chaque format fournit une classe d’options dédiée. Par exemple, charger un fichier STL avec des options explicites :

import com.aspose.threed.*;

public class LoadWithOptions {
    public static void main(String[] args) throws Exception {
        StlLoadOptions opts = new StlLoadOptions();
        Scene scene = Scene.fromFile("part.stl", opts);

        // Inspect the loaded scene
        System.out.println("Root children: "
            + scene.getRootNode().getChildNodes().size());

        // Re-export as OBJ
        scene.save("part.obj");
    }
}

Le Scene.fromFile() la méthode statique accepte l’un des types d’options de chargement : ObjLoadOptions, StlLoadOptions, GltfLoadOptions, ou FbxLoadOptions.

Parcourir le graphe de scène

Une fois la scène chargée, vous pouvez parcourir l’arbre de nœuds pour inspecter ou modifier son contenu :

import com.aspose.threed.*;

public class TraverseScene {
    public static void main(String[] args) throws Exception {
        Scene scene = Scene.fromFile("model.gltf");

        for (Node child : scene.getRootNode().getChildNodes()) {
            System.out.println("Node: " + child.getName());

            Transform t = child.getTransform();
            System.out.println("  Translation: " + t.getTranslation());

            Entity entity = child.getEntity();
            if (entity instanceof Mesh) {
                Mesh mesh = (Mesh) entity;
                System.out.println("  Vertices: "
                    + mesh.getControlPoints().size());
            }
        }
    }
}

Ce modèle est utile pour le débogage, la génération de rapports sur le contenu du modèle, ou la modification sélective de parties d’une scène avant de la réexporter.

Appliquer des transformations

Le positionnement des nœuds dans l’espace 3D se fait via le Transform objet sur chaque Node:

import com.aspose.threed.*;

public class TransformExample {
    public static void main(String[] args) throws Exception {
        Scene scene = new Scene();

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

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

        // Child's world position is (15, 0, 0) due to
        // parent-child transform inheritance

        scene.save("transformed.gltf");
    }
}

Les transformations suivent le modèle d’héritage parent‑enfant standard : la position d’un enfant dans l’espace mondial est la combinaison de sa transformation locale et de toutes les transformations des ancêtres jusqu’à la racine.

Ce qui est inclus

La bibliothèque est fournie avec un ensemble ciblé de fonctionnalités conçues autour du modèle de graphe de scène 3D.

Graphe de scène

Le graphe de scène est l’épine dorsale de l’API. Chaque fichier 3D est représenté sous forme d’une structure arborescente :

Matériaux

La bibliothèque fournit un modèle de matériau PBR (Physically Based Rendering) :

• PbrMaterial – physically based rendering material avec albedo, metalness, roughness, emissive color et transparency. C’est la seule classe de matériau concrète disponible dans l’édition Java.

Utilitaires Mathématiques

Le com.aspose.threed Le package inclut les primitives mathématiques essentielles :

• Vector3 – vecteur à 3 composantes pour les positions, les directions et les couleurs.
• Matrix4 – matrice de transformation 4x4.
• Quaternion – représentation de rotation.
• BoundingBox – boîte englobante alignée sur les axes pour les requêtes spatiales.

Vector3 a = new Vector3(1, 0, 0);
Vector3 b = new Vector3(0, 1, 0);
Vector3 c = Vector3.add(a, b); // (1, 1, 0)

Options de chargement et d’enregistrement

Chaque format possède des classes d’options dédiées qui vous permettent de contrôler le comportement d’importation et d’exportation :

Par exemple, pour exporter glTF avec du JSON formaté de façon lisible et un système de coordonnées inversé :

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

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

Formats pris en charge

Le tableau suivant résume les formats que Aspose.3D FOSS pour Java peut lire et écrire.

OBJ, STL, glTF et GLB prennent en charge à la fois le chargement et l’enregistrement. FBX est pris en charge uniquement pour l’import.

Guide de sélection des formats

Le choix du bon format dépend de votre cas d’utilisation :

• OBJ est idéal lorsque vous avez besoin d’une compatibilité maximale entre les outils 3D. Pratiquement toutes les applications de modélisation peuvent lire et écrire OBJ. Il fonctionne bien pour l’échange de maillages, mais ne transporte que des informations de matériau de base via les fichiers MTL associés.
• STL est le format de choix pour les flux de travail d’impression 3D. Il stocke la géométrie triangulée brute sans matériaux ni hiérarchie de scène, ce qui correspond exactement à ce que le logiciel de découpe attend. Si votre pipeline se termine à une imprimante 3D, STL est le choix évident.
• glTF est la norme moderne pour le web et la 3D en temps réel. Il prend en charge les matériaux PBR, les hiérarchies de scène complètes, et est conçu pour une transmission efficace. Utilisez glTF lors de la création de visionneuses web, en travaillant avec three.js ou Babylon.js, ou en ciblant tout pipeline de rendu en temps réel.
• FBX est profondément intégré aux flux de travail de développement de jeux et de création de contenu numérique. Il prend en charge des données de scène riches, y compris les hiérarchies et les matériaux. Aspose.3D FOSS for Java prend en charge FBX import uniquement – utilisez-le pour charger des actifs FBX et les convertir en d’autres formats.

Limitations connues

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

Open Source et licence

Aspose.3D FOSS pour Java est publié sous le Licence MIT. Cela signifie que vous êtes libre de :

• Utiliser la bibliothèque dans des applications commerciales et propriétaires.
• Modifier le code source pour l’adapter à vos besoins.
• Distribuez la bibliothèque dans le cadre de votre propre logiciel.

Il n’y a aucun frais de redevance, aucune limite d’utilisation et aucune exigence d’attribution au-delà de ce que spécifie la licence MIT.

Le code source complet est hébergé sur GitHub, et les contributions sont les bienvenues : https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Exigences système

Premiers pas

Voici les ressources pour vous aider à démarrer :

• Documentation – des guides complets et des présentations d’API sont disponibles sur le Aspose.3D site de documentation.
• Base de connaissances – des articles pratiques et des conseils de dépannage dans le Aspose.3D KB.
• Référence API – référence détaillée des classes et des méthodes à Aspose.3D Référence de l’API.
• Code source – parcourir et contribuer sur GitHub.
• Maven Central – le paquet est publié sous com.aspose:aspose-3d-foss sur Maven Central.

Cas d’utilisation courants

Voici quelques scénarios pratiques où Aspose.3D FOSS pour Java s’intègre bien :

Pipelines de conversion de formats

De nombreuses équipes reçoivent des actifs 3D dans un format mais en ont besoin dans un autre. Une équipe de conception peut travailler en FBX tandis que l’équipe web a besoin de glTF. La bibliothèque vous permet de créer des pipelines de conversion automatisés :

// Convert all incoming FBX assets to GLB for the web team
Scene scene = Scene.fromFile("asset.fbx");

GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);

scene.save("asset.glb", opts);

3D Model Inspection and Validation

Avant d’intégrer un actif 3D dans votre application, vous pouvez vouloir valider son contenu – vérifier le nombre de nœuds, valider la géométrie, ou confirmer que les éléments attendus sont présents :

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

int nodeCount = scene.getRootNode().getChildNodes().size();
System.out.println("Top-level nodes: " + nodeCount);

for (Node child : scene.getRootNode().getChildNodes()) {
    if (child.getEntity() instanceof Mesh) {
        Mesh mesh = (Mesh) child.getEntity();
        System.out.println(child.getName() + ": "
            + mesh.getControlPoints().size() + " vertices");
    }
}

Assemblage de scène

Vous pouvez charger plusieurs modèles et les combiner en une seule scène :

Scene scene = new Scene();

Scene part1 = Scene.fromFile("chassis.obj");
Scene part2 = Scene.fromFile("wheels.obj");

// Add nodes from each part into the combined scene
for (Node child : part1.getRootNode().getChildNodes()) {
    scene.getRootNode().getChildNodes().add(child);
}
for (Node child : part2.getRootNode().getChildNodes()) {
    scene.getRootNode().getChildNodes().add(child);
}

scene.save("assembled.gltf");

Prochaines étapes

Dans les prochains articles, nous couvrirons :

• Une analyse approfondie des fonctionnalités clés de l’API de graphe de scène, des matériaux et des utilitaires mathématiques.
• Un guide pratique pour travailler avec chaque format 3D pris en charge – OBJ, STL, glTF et FBX – incluant les options de chargement/enregistrement et les modèles de conversion par lots.

Restez à l’écoute, et n’hésitez pas à explorer la bibliothèque et à partager vos retours sur GitHub.