Introducció Aspose.3D FOSS per a Java

Estem molt contents d’anunciar la disponibilitat de 3D FOSS per a Java - una biblioteca de codi obert gratuït per treballar amb formats de fitxers 3D en aplicacions Java. Construïda com a solució pura de Java sense dependències natives, la biblioteca es fa servir de JavaScript 21 i posteriorment, fent-la accessible a un ampli ventall de projectes i entorns.

Aquest post recorre el que ofereix la biblioteca, com començar i on anar d’aquí.

Què és el 3D FOSS per a Java?

Aspose.3D FOSS per a Java és una llibreria de processament de fitxers 3D lleuger publicada sota el Llicència MIT.Proporciona una API de gràfics d’escena que li permet carregar, inspeccionar, transformar i salvar models 3D a través de diversos formats àmpliament utilitzats. La biblioteca està escrita en Java i no requereix cap configuració binària o específica per la plataforma.

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

Principals destacaments

• El Java pur - No hi ha JNI, no hi haurà biblioteques natives, ni restriccions de la plataforma.
• El programa 21+ compatible amb.
• Mit licensiada - utilitzar-lo en projectes personals, comercials o propietaris sense restriccions.
• Arquitectura de escenaris - un arbre familiar de nodes, mesquites, càmeres i materials.
• Suport multiformat - llegir i escriure els arxius OBJ, STL, glTF 2.0 i GLB; llegint els fets FBX.

Inici ràpid

Instal·lació de Maven

Afegeix la següent dependència a la teva pom.xml:

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

La seva primera conversió

El cas més senzill d’ús és carregar un fitxer 3D en un format i salvar-lo en l’altre.Aquí hi ha una conversió de dues línies des d’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 La classe és el punt d’entrada central.Cal·la Scene.fromFile() amb un camí de fitxer per carregar un model, després trucar save() La biblioteca infereix el format de l’extenssió del fitxer.

Construir una escena de Scratch

També es poden fer escenes programàticament:

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 nucli infantil anomenat “Box” sota la arrel, el posi en coordenades (1, 2, 3), i exporta el resultat com a fitxer glTF.

Carregar amb opcions específiques de format

Quan necessites un control més finós sobre el procés de càrrega, cada format proporciona una classe d’opcions dedicades. 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.

Travessar el Grau de l’escena

Una vegada que una escena és carregada, es pot caminar a l’arbre de nucli per inspeccionar o modificar els seus continguts:

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 la descomposició, generar informes sobre el contingut del model o modificar selectivament parts d’una escena abans de reexportar.

Aplicació de transformacions

Positió de nodes en l’espai 3D es fa a través del Transform Objecte en 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 d’herència parental-infant: la posició espacial del nen és la combinació de la seva transformació local i tots els avantpassats es transformen fins a la raïm.

Què s’inclou

La biblioteca embarca amb un conjunt centrat de capacitats dissenyades al voltant del model de escena-graf 3D.

Escena de gràfics

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

Materials

La biblioteca proporciona un model de material PBR (Rendering Físicament Based):

• PbrMaterial - material de renderització basat en físic amb albedo, metal·litat, duresa, color emissor i transparència. aquest és l’única classe de material concret disponible a la edició Java.

Utilitats matemàtiques

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

• Vector 3 - Vector de 3 components per a posicions, direccions i colors.
• Matriu 4 - 4x4 matriu de transformació.
• Quaternitat representació de rotació.
• BoundingBox - Caixa de llarga fila alineada a la punta per a les 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)

Carregar i salvar opcions

Cada format té classes d’opcions dedicades que li permeten controlar el comportament de les importacions i exportacions:

Per exemple, per exportar glTF amb JSON ben imprès i un sistema de coordenades flipped:

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

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

Formats suportats

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

OBJ, STL, glTF i GLB suporten tant la càrrega com l’estalvi. FBX és suportat per a les importacions només.

Guia de selecció de format

La selecció del format correcte depèn de la seva utilització:

• OBJ És ideal quan necessites la màxima compatibilitat a través d’eines 3D. Quasi cada aplicació de modelatge pot llegir i escriure OBJ. Funciona bé per a l’intercanvi de dades mesh però només porta informació material bàsica a partir dels fitxers MTL companys.
• STL És el format de l’elecció per a fluxos de treball d’impressió 3D. Està emmagatzemant geometria triangulada cru sense materials o jerarquia de escena, que és exactament el que esperen els programes de tallador. Si el seu pipeline acaba en una impressora 3d, STL és la opció senzilla.
• GSTF És la norma moderna per a web i 3D en temps real. S’aporta materials PBR, jerarquies de escena completa, i està dissenyat per una transmissió eficient. Utilitza glTF quan es construeixen els visuals basats en el web, treballant amb tres.js o Babylon.js, o dirigint qualsevol pipeline de rendiment en tempo real .
• FBX És profundament integrada en el desenvolupament del joc i els fluxos de treball de creació de contingut digital. recolza dades d’escena rics, incloent hieràries i materials. Aspose.3D FOSS per a Java suporta FBX Només importar - utilitzar-lo per carregar els actius FBX i convertir-los en altres formats.

Limitacions conegudes

És important que tinguem en compte que Scene.render() És No suportat en l’edició FOSS. cridant aquest mètode serà llançar un UnsupportedOperationException.La biblioteca està dissenyada per al processament 3D basat en arxius - carregar, manipular, transformar i salvar models - en lloc de renderitzar a temps real a una pantalla.

Open Source i llicència

Aspose.3D FOSS per a Java es publica sota el Llicència MIT.Això significa que vostè és lliure de:

• Utilitzar la biblioteca en aplicacions comercials i propietàries.
• Modifica el codi font per a adaptar-se a les teves necessitats.
• Distribuïu la biblioteca com a part del vostre propi programari.

No hi ha cap taxa de lleialtat, no hi haurà límits d’ús i no s’han de fer requisits per a l’adjudicació més enllà del que especifica la llicència MIT.

El codi font complet és hostat a GitHub, i les contribucions són benvingudes: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-per-Java

Requisits del sistema

Començar a fer

Aquí teniu els recursos per ajudar-vos a pujar i córrer:

• Documentació - Guides i passadissos API complets estan disponibles a la Web de documentació Aspose.3D.
• Base de coneixement - Com practicar els articles i les consells de resolució de problemes en el Tècnic 3D KB.
• Referència API - Referència de classe i mètode detallada a la Aspose.3D API Referència.
• Codi de font - Brouïr i contribuir a la GitHub.
• Maven Central - El paquet es publica com a com.aspose:aspose-3d-foss a la Maven Central.

Casos d’ús comú

Aquí teniu alguns escenaris pràctics on Aspose.3D FOSS per a Java s’ajusta bé:

Formació de tubs de conversió

Moltes equips reben els actius 3D en un format, però els necessiten en l’altre.Un equip de disseny pot treballar en FBX mentre que el web té necessitat d’glTF. La biblioteca li permet construir tubs 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 actiu 3D en la seva aplicació, pot ser que vulgui validar el seu contingut - comprovant els comptes de nuclis, verificar la geometria o confirmar que s’esperen elements:

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

Assemblea de l’escena

Podeu carregar diversos models i combinar-los en una sola 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è és el següent

En els propers post, cobrirem:

• Un profund immersor en les característiques clau de l’API, materials i utilitats matemàtiques.
• Un guia pràctic per treballar amb cada format 3D suportat - OBJ, STL, glTF i FBX - incloent opcions de càrrega / estalvi i patrons de conversió d’un batx.

Mantenir-se en la seva forma, i sentir-te lliure d’explorar la biblioteca i compartir el teu comentari a GitHub.