Comment télécharger les modèles 3D en Java

Aspose.3D FOSS pour Java fournit une API simple pour ouvrir les fichiers 3D sans dépendance native. Scene objet vous pouvez marcher la hiérarchie des nœuds et lire les données géométriques crus pour chaque mesh dans la scène.

Guide étape par étapes

Étape 1 : Ajouter la dépendance Maven

Ajoutez la dépendance Aspose.3D FOSS à votre pom.xml.Aucune bibliothèque native supplémentaire n’est requise.

<dependency>
  <groupId>org.aspose</groupId>
  <artifactId>aspose-3d-foss</artifactId>
  <version>26.5.0</version>
</dependency>

Étape 2 : Importer les classes requises

Le Scene classe est le conteneur de premier niveau pour tous les données 3D. Importer avec la Node, Mesh, et toutes les classes de charge spécifiques au format dont vous avez besoin.

import com.aspose.threed.Scene;
import com.aspose.threed.Node;
import com.aspose.threed.Mesh;
import com.aspose.threed.Entity;
import com.aspose.threed.ObjLoadOptions;
import com.aspose.threed.GltfLoadOptions;
import com.aspose.threed.StlLoadOptions;

Toutes les classes publiques vivent sous la com.aspose.threed Le paquet.

Étape 3 : Remplissez un fichier

Utilisez le statique Scene.fromFile() méthode d’ouverture de tout format supporté. La bibliothèque détecte le format automatiquement à partir de l’extension de fichier.

// Automatic format detection from the file extension
Scene scene = Scene.fromFile("model.obj");

Alternativement, créer un Scene Instance et appel open().Ceci est utile lorsque vous souhaitez passer les options de charge ou gérer des erreurs explicitement:

Scene scene = new Scene();
scene.open("model.obj");

Les deux approches soutiennent les fichiers OBJ, STL (binaire et ASCII), glTF 2.0 / GLB et FBX.

Étape 4 : Traverse Scene Nodes

Une scène chargée est un arbre de Node Les objets enracinés à scene.getRootNode().Utiliser getChildNodes() Pour l’état et visiter tous les nœuds :

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

public class SceneWalker {
    public static void main(String[] args) throws Exception {
        Scene scene = Scene.fromFile("model.obj");
        walkNode(scene.getRootNode(), 0);
    }

    static void walkNode(Node node, int depth) {
        String indent = "  ".repeat(depth);
        System.out.println(indent + "Node: " + node.getName());
        for (Node child : node.getChildNodes()) {
            walkNode(child, depth + 1);
        }
    }
}

Chacun Node peut être porté à zéro ou plus Entity objets (mesées, caméras, lumières). vérifier node.getEntities() pour inspecter chaque entité attachée à un node, ou utiliser node.getEntity() pour la récupération de l’entité primaire.

Étape 5 : Accès aux données Vertex et Polygon

Coupez l’entité d’un node à Mesh et appeler getControlPoints() pour les positions vertéx et getPolygons() Pour les index de visage :

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

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

for (Node node : scene.getRootNode().getChildNodes()) {
    Entity entity = node.getEntity();
    if (entity instanceof Mesh) {
        Mesh mesh = (Mesh) entity;
        System.out.printf("Mesh '%s': %d vertices, %d polygons%n",
            node.getName(),
            mesh.getControlPoints().size(),
            mesh.getPolygonCount());

        // First vertex position (Vector4: x, y, z, w)
        if (!mesh.getControlPoints().isEmpty()) {
            var v = mesh.getControlPoints().get(0);
            System.out.printf("  First vertex: (%.4f, %.4f, %.4f)%n", v.x, v.y, v.z);
        }

        // First polygon: array of control-point indices
        if (!mesh.getPolygons().isEmpty()) {
            int[] poly = mesh.getPolygons().get(0);
            System.out.println("  First polygon indices: " + java.util.Arrays.toString(poly));
        }
    }
}

mesh.getControlPoints() Retour à A List<Vector4> où x, y, z Il prend la position et w Il est le coordonné homogène (normalement 1.0).

mesh.getPolygons() Retour à A List<int[]> où chaque array est le ensemble ordonné d’indices de point de contrôle pour un visage.

Étape 6: Applicez les options de charge spécifiques au format

Pour un contrôle fine-grain sur la façon dont un fichier est interprété, passez une option de charge à Scene.fromFile() ou scene.open().

Les fichiers OBJ - ObjLoadOptions:

import com.aspose.threed.Scene;
import com.aspose.threed.ObjLoadOptions;

ObjLoadOptions options = new ObjLoadOptions();
options.setFlipCoordinateSystem(true);  // Convert right-hand Y-up to Z-up
options.setScale(0.01);                  // Convert centimetres to metres
options.setEnableMaterials(true);        // Load the .mtl material file alongside
options.setNormalizeNormal(true);        // Normalize all normals to unit length

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

Fichiers GLTF / GLB - GltfLoadOptions:

import com.aspose.threed.Scene;
import com.aspose.threed.GltfLoadOptions;

GltfLoadOptions options = new GltfLoadOptions();
options.setFlipCoordinateSystem(true);  // Flip the coordinate system if needed

Scene scene = Scene.fromFile("model.glb", options);

Les fichiers STL - StlLoadOptions:

import com.aspose.threed.Scene;
import com.aspose.threed.StlLoadOptions;

StlLoadOptions options = new StlLoadOptions();
options.setFlipCoordinateSystem(true);
options.setRecalculateNormal(true);  // Recompute normals from face geometry

Scene scene = Scene.fromFile("model.stl", options);

Formats d’importation soutenus

Formats	Extension	Notes
OBJ	`.obj`	Wavefront OBJ : optionnel `.mtl` fichier ; permet de `ObjLoadOptions.setEnableMaterials(true)`
STL	`.stl`	Les modes ASCII et binaires sont détectés automatiquement.
GTTF	`.gltf`, `.glb`	glTF 2.0; les variantes binaire GLB et JSON sont tous deux soutenus
FBX	`.fbx`	Binaires FBX supportés

Problèmes communs et fixations

IOException sur le chargement Vérifiez que le chemin de fichier est correct et que ce fichie existe. Utilisez des chemins absolu pendant le développement pour éliminer l’ambiguïté du travail-directeur.

NullPointerException L’entité d’accès - Pas chaque node porte la géométrie. toujours garde avec node.getEntity() instanceof Mesh avant de se lancer ou d’y faire un iterate node.getEntities() Traiter les nodes avec plusieurs objets attachés.

Système de coordination mismatch Si le modèle chargé apparaît flûté ou roté, utilisez setFlipCoordinateSystem(true) Pour les options de charge appropriées (ObjLoadOptions, GltfLoadOptions,ou StlLoadOptions).

Le scénario se charge mais getChildNodes() est vide — Certains fichiers stockent la géométrie sous les sous-scénarios plutôt que le node racine. scene.getSubScenes() et inspecter le noyau de racine de chaque sous-scène.

Questions fréquemment posées (FAQ)

Quels formats puis-je charger ?

OBJ, STL (binaire et ASCII), glTF 2.0 / GLB, et FBX. La détection du format est automatique en fonction de l’extension de fichier lorsque vous appelez Scene.fromFile().

Puis-je faire un chargement d’un courant ?

Oui oui. scene.open(InputStream) et Scene.fromStream(InputStream) Les deux ont accepté Java. InputStream.Vous pouvez aussi passer une FileFormat paramètre lorsque le courant ne porte pas une extension.

La bibliothèque est-elle sécurisée ?

Chacun Scene L’instance est indépendante et ne partage pas l’état mutable avec d’autres instances.

Comment puis-je lire les comptes de polygone sans itérer chaque visage ?

Appel à mesh.getPolygonCount() Pour un compte complet direct.