Presentant Aspose.3D FOSS per a Java

Estem emocionats d’anunciar la disponibilitat de Aspose.3D FOSS per Java – una biblioteca gratuïta i de codi obert per treballar amb formats de fitxers 3D en aplicacions Java. Construïda com una solució pura Java sense dependències natives, la biblioteca s’executa a Java 21 i posteriors, fent-la accessible a una àmplia gamma de projectes i entorns.

Aquest article repassa què ofereix la biblioteca, com començar i cap a on anar a partir d’ara.

Què és Aspose.3D FOSS per a Java?

Aspose.3D FOSS per Java és una biblioteca lleugera de processament de fitxers 3D publicada sota la llicència MIT. Proporciona una API de gràfic de escena que et permet carregar, inspeccionar, transformar i desar models 3D en diversos formats àmpliament utilitzats. La biblioteca està escrita completament en Java i no requereix binaris natius externs ni configuracions específiques de plataforma.

El codi font està disponible a GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Aspectes clau

• Pur Java – sense JNI, sense biblioteques natives, sense restriccions de plataforma.
• Java 21+ compatible.
• amb llicència MIT – utilitza’l en projectes personals, comercials o propietaris sense restriccions.
• Arquitectura de graf d’escena – un arbre familiar de nodes, malles, càmeres i materials.
• Suport multiformat – llegeix i escriu fitxers OBJ, STL, glTF 2.0 i GLB; llegeix fitxers FBX.

Inici ràpid

Instal·lació de Maven

Afegeix la següent dependència al teu pom.xml:

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

La teva primera conversió

El cas d’ús més senzill consisteix a carregar un fitxer 3D en un format i desar-lo en un altre. Aquí teniu una conversió de dues línies de OBJ a 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");
    }
}

El Scene classe és el punt d’entrada central. Crida Scene.fromFile() amb una ruta de fitxer per carregar un model, després crida save() amb el camí de destinació. La biblioteca infereix el format a partir de l’extensió del fitxer.

Construint una escena des de zero

També pots construir escenes de manera programàtica:

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

Això crea una nova escena, afegeix un node fill anomenat “Box” sota l’arrel, el posiciona a les coordenades (1, 2, 3) i exporta el resultat com a fitxer glTF.

Càrrega amb opcions específiques del format

Quan necessiteu un control més gran sobre el procés de càrrega, cada format ofereix una classe d’opcions dedicada. Per exemple, carregar un fitxer STL amb opcions explícites:

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

El Scene.fromFile() el mètode estàtic accepta qualsevol dels tipus d’opció de càrrega: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, o FbxLoadOptions.

Recorregut del graf de l’escena

Un cop una escena està carregada, podeu recórrer l’arbre de nodes per inspeccionar o modificar el seu contingut:

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

Aquest patró és útil per a depuració, generar informes sobre el contingut del model o modificar selectivament parts d’una escena abans de tornar a exportar-la.

Aplicació de transformacions

El posicionament de nodes en l’espai 3D es fa a través del Transform objecte a cada 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 transformacions segueixen el model estàndard d’herència pare-filla: la posició en l’espai mundial d’un fill és la combinació de la seva transformació local i totes les transformacions dels avantpassats fins a l’arrel.

Què s’inclou

La biblioteca s’entrega amb un conjunt enfocat de capacitats dissenyat al voltant del model de gràfic d’escena 3D.

Gràfic d’escena

El gràfic d’escena és la columna vertebral de l’API. Cada fitxer 3D es representa com una estructura d’arbre:

Materials

La biblioteca proporciona un model de material PBR (Physically Based Rendering):

• PbrMaterial – material de renderització basat físicament amb albedo, metal·linització, rugositat, color emissiu i transparència. Aquest és l’única classe de material concreta disponible a l’edició Java.

Utilitats Matemàtiques

El com.aspose.threed el paquet inclou primitives matemàtiques essencials:

• Vector3 – vector de 3 components per a posicions, direccions i colors.
• Matrix4 – matriu de transformació 4x4.
• Quaternió – representació de rotació.
• BoundingBox – caixa delimitadora alineada amb els eixos per a consultes espacials.

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

Opcions de càrrega i desament

Cada format té classes d’opcions dedicades que et permeten controlar el comportament d’importació i exportació:

Per exemple, per exportar glTF amb JSON formatat de manera llegible i un sistema de coordenades invertit:

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

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

Formats compatibles

La taula següent resumeix els formats que Aspose.3D FOSS per a Java pot llegir i escriure.

OBJ, STL, glTF i GLB admeten tant la càrrega com el desament. FBX només és compatible per a la importació.

Guia de selecció de formats

Escollir el format adequat depèn del vostre cas d’ús:

• OBJ és ideal quan necessites la màxima compatibilitat entre les eines 3D. Gairebé qualsevol aplicació de modelatge pot llegir i escriure OBJ. Funciona bé per a l’intercanvi de dades de malla, però només transporta informació bàsica de materials a través dels fitxers MTL associats.
• STL és el format escollit per als fluxos de treball d’impressió 3D. Emmagatzema geometria triangulada en brut sense materials ni jerarquia d’escena, que és exactament el que espera el programari de laminat. Si la teva cadena acaba en una impressora 3D, STL és l’opció més directa.
• glTF és l’estàndard modern per al web i el 3D en temps real. Admet materials PBR, jerarquies d’escena completes i està dissenyat per a una transmissió eficient. Utilitza glTF quan construeix visualitzadors basats en web, treballes amb three.js o Babylon.js, o apunts a qualsevol cadena de renderització en temps real.
• FBX està profundament integrat en els fluxos de treball de desenvolupament de jocs i creació de contingut digital. Admet dades de escena riques, incloent jerarquies i materials. Aspose.3D FOSS per a Java admet FBX només importació – utilitza’l per carregar actius FBX i convertir-los a altres formats.

Limitacions conegudes

És important tenir en compte que Scene.render() és no és compatible a l’edició FOSS. Cridar aquest mètode llençarà una UnsupportedOperationException. La biblioteca està dissenyada per al processament 3D basat en fitxers – càrrega, manipulació, transformació i desament de models – més que per al renderitzat en temps real a una pantalla.

Codi obert i llicenciament

Aspose.3D FOSS per a Java es publica sota la MIT License. Això vol dir que podeu:

• Utilitzeu la biblioteca en aplicacions comercials i propietàries.
• Modifiqueu el codi font per adaptar-lo a les vostres necessitats.
• Distribuïu la biblioteca com a part del vostre propi programari.

No hi ha cap taxa de regalies, cap límit d’ús i cap requisit d’atribució més enllà del que especifica la llicència MIT.

El codi font complet està allotjat a GitHub i les contribucions són benvingudes: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Requisits del sistema

Començar

Aquí teniu els recursos per ajudar-vos a posar-vos en marxa:

• Documentació – guies completes i recorreguts d’API estan disponibles a la Aspose.3D site de documentació.
• Base de coneixement – articles pràctics de com fer i consells de resolució de problemes a la Aspose.3D KB.
• Referència d’API – referència detallada de classes i mètodes a la Aspose.3D Referència de l’API.
• Codi font – navega i contribueix a GitHub.
• Maven Central – el paquet es publica com a com.aspose:aspose-3d-foss a Maven Central.

Casos d’ús comuns

A continuació es presenten alguns escenaris pràctics on Aspose.3D FOSS per a Java s’adapta bé:

Fluxos de conversió de formats

Molts equips reben actius 3D en un format però els necessiten en un altre. Un equip de disseny pot treballar amb FBX mentre que l’equip web necessita glTF. La biblioteca et permet crear fluxos de conversió automatitzats:

// 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

Abans d’integrar un recurs 3D a la teva aplicació, potser voldràs validar-ne el contingut – comprovant el nombre de nodes, verificant la geometria o confirmant que els elements esperats estan presents:

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

Muntatge d’escena

Pots carregar diversos models i combinar-los en una única escena:

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");

Què ve a continuació

En les properes publicacions, cobrirem:

• Una anàlisi profunda de les característiques clau de l’API de gràfic d’escenes, els materials i les utilitats matemàtiques.
• Una guia pràctica per treballar amb cada format 3D compatible – OBJ, STL, glTF i FBX – incloent opcions de càrrega/descarrega i patrons de conversió per lots.

Estigueu atents, i no dubteu a explorar la biblioteca i compartir els vostres comentaris a GitHub.