Prezentăm Aspose.3D FOSS pentru Java

Suntem încântați să anunțăm disponibilitatea de Aspose.3D FOSS for Java – o bibliotecă gratuită, open-source pentru lucrul cu formate de fișiere 3D în aplicații Java. Construită ca o soluție Java pură, fără dependențe native, biblioteca rulează pe Java 21 și ulterior, făcând-o accesibilă pentru o gamă largă de proiecte și medii.

Acest articol trece în revistă ce oferă biblioteca, cum să începi și unde să mergi de aici.

Ce este Aspose.3D FOSS pentru Java?

Aspose.3D FOSS for Java este o bibliotecă ușoară de procesare a fișierelor 3D publicată sub MIT license. Oferă o API de tip scenă-grafică care vă permite să încărcați, inspectați, transformați și salvați modele 3D în mai multe formate larg utilizate. Biblioteca este scrisă în întregime în Java și nu necesită binare native externe sau configurații specifice platformei.

Codul sursă este disponibil pe GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Aspecte cheie

• Pur Java – fără JNI, fără biblioteci native, fără restricții de platformă.
• Java 21+ compatibil.
• Licențiat MIT – folosește-l în proiecte personale, comerciale sau proprietare fără restricții.
• Arhitectură de graf de scenă – un arbore familiar de noduri, mesh-uri, camere și materiale.
• Suport multi-format – citește și scrie fișiere OBJ, STL, glTF 2.0 și GLB; citește fișiere FBX.

Începe rapid

Instalare Maven

Adaugă următoarea dependență în proiectul tău pom.xml:

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

Prima ta conversie

Cel mai simplu caz de utilizare este încărcarea unui fișier 3D într-un format și salvarea lui într-altul. Iată o conversie în două linii din OBJ în 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");
    }
}

The Scene clasa este punctul central de intrare. Apelă Scene.fromFile() cu o cale de fișier pentru a încărca un model, apoi apelă save() cu calea țintă. Biblioteca deduce formatul din extensia fișierului.

Construirea unei scene de la zero

De asemenea, puteți construi scene programatic:

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

Acest lucru creează o scenă nouă, adaugă un nod copil numit „Box” sub rădăcină, îl poziționează la coordonatele (1, 2, 3) și exportă rezultatul ca fișier glTF.

Încărcare cu opțiuni specifice formatului

Când aveți nevoie de un control mai fin asupra procesului de încărcare, fiecare format oferă o clasă de opțiuni dedicată. De exemplu, încărcarea unui fișier STL cu opțiuni explicite:

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

The Scene.fromFile() metoda statică acceptă oricare dintre tipurile de opțiuni de încărcare: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, sau FbxLoadOptions.

Parcurgerea graficului scenei

După ce o scenă este încărcată, puteți parcurge arborele de noduri pentru a inspecta sau modifica conținutul acestuia:

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

Acest model este util pentru depanare, generarea de rapoarte despre conținutul modelului sau modificarea selectivă a părților unei scene înainte de reexportare.

Aplicarea transformărilor

Poziționarea nodurilor în spațiul 3D se realizează prin Transform obiectul pe fiecare 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");
    }
}

Transformările urmează modelul standard de moștenire părinte-copil: poziția în spațiu mondial a unui copil este combinația transformării locale și a tuturor transformărilor strămoșilor până la rădăcină.

Ce este inclus

Biblioteca este livrată cu un set concentrat de capabilități concepute în jurul modelului de graf de scenă 3D.

Graf de scenă

Graful de scenă este coloana vertebrală a API-ului. Fiecare fișier 3D este reprezentat ca o structură arboreală:

Materiale

Biblioteca oferă un model de material PBR (Physically Based Rendering):

• PbrMaterial – material de redare bazat pe fizică cu albedo, metalness, roughness, emissive color și transparență. Acesta este singurul tip concret de material disponibil în ediția Java.

Utilitare Matematice

The com.aspose.threed pachetul include primitive matematice esențiale:

• Vector3 – vector de 3 componente pentru poziții, direcții și culori.
• Matrix4 – matrice de transformare 4x4.
• Cuaternion – reprezentare a rotației.
• BoundingBox – cutie de delimitare aliniată pe axe pentru interogări spațiale.

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

Opțiuni de încărcare și salvare

Fiecare format are clase de opțiuni dedicate care vă permit să controlați comportamentul de import și export:

De exemplu, pentru a exporta glTF cu JSON formatat frumos și cu sistemul de coordonate inversat:

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

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

Formate suportate

Următorul tabel rezumă formatele pe care Aspose.3D FOSS pentru Java le poate citi și scrie.

OBJ, STL, glTF și GLB suportă atât încărcarea, cât și salvarea. FBX este suportat doar pentru import.

Ghid de selecție a formatelor

Alegerea formatului potrivit depinde de cazul tău de utilizare:

• OBJ este ideal când aveți nevoie de compatibilitate maximă între instrumentele 3D. Aproape fiecare aplicație de modelare poate citi și scrie OBJ. Funcționează bine pentru schimbul de date de mesh, dar transportă doar informații de bază despre material prin fișierele MTL însoțitoare.
• STL este formatul preferat pentru fluxurile de lucru de imprimare 3D. Stochează geometrie triunghiulară brută fără materiale sau ierarhie de scenă, exact așa cum așteaptă software-ul de tăiere. Dacă fluxul tău se termină la o imprimantă 3D, STL este alegerea evidentă.
• glTF este standardul modern pentru web și 3D în timp real. Suportă materiale PBR, ierarhii complete de scenă și este conceput pentru transmisie eficientă. Folosește glTF când construiești vizualizatoare web, lucrezi cu three.js sau Babylon.js, sau vizezi orice flux de redare în timp real.
• FBX este profund integrat în fluxurile de lucru de dezvoltare a jocurilor și de creare a conținutului digital. Suportă date de scenă bogate, inclusiv ierarhii și materiale. Aspose.3D FOSS pentru Java suportă FBX doar import – folosește-l pentru a încărca active FBX și a le converti în alte formate.

Limitări cunoscute

Este important de remarcat că Scene.render() este nu este suportat în ediția FOSS. Apelarea acestei metode va genera o UnsupportedOperationException. Biblioteca este concepută pentru procesarea 3D bazată pe fișiere — încărcare, manipulare, transformare și salvare a modelelor — mai degrabă decât pentru redarea în timp real pe un ecran.

Open Source și Licențiere

Aspose.3D FOSS pentru Java este lansat sub MIT License. Aceasta înseamnă că ești liber să:

• Utilizați biblioteca în aplicații comerciale și proprietare.
• Modificați codul sursă pentru a se potrivi nevoilor dumneavoastră.
• Distribuiți biblioteca ca parte a propriului dvs. software.

Nu există taxe de redevență, nu există limite de utilizare și nu există cerințe de atribuire în afara celor specificate de licența MIT.

Codul sursă complet este găzduit pe GitHub, iar contribuțiile sunt binevenite: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Cerințe de sistem

Începeți

Iată resursele care vă vor ajuta să începeți:

• Documentație – ghiduri cuprinzătoare și prezentări ale API-ului sunt disponibile pe Aspose.3D site-ul de documentație.
• Bază de cunoștințe – articole practice de tip „cum să” și sfaturi de depanare în Aspose.3D KB.
• Referință API – referință detaliată a claselor și metodelor la Referință API Aspose.3D.
• Cod sursă – navigați și contribuiți pe GitHub.
• Maven Central – pachetul este publicat ca com.aspose:aspose-3d-foss pe Maven Central.

Cazuri de utilizare comune

Iată câteva scenarii practice în care Aspose.3D FOSS pentru Java se potrivește bine:

Fluxuri de conversie a formatelor

Multe echipe primesc active 3D într-un format, dar le necesită într-altul. O echipă de design ar putea lucra în FBX, în timp ce echipa web are nevoie de glTF. Biblioteca vă permite să construiți fluxuri de conversie automate:

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

Înainte de a integra un asset 3D în aplicația dumneavoastră, s-ar putea să doriți să validați conținutul acestuia – verificând numărul de noduri, confirmând geometria sau asigurându-vă că elementele așteptate sunt prezente:

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

Asamblarea scenei

Puteți încărca mai multe modele și să le combinați într-o singură scenă:

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

Ce urmează

În postările viitoare, vom acoperi:

• O analiză aprofundată a funcționalităților cheie ale API-ului de graf de scenă, a materialelor și a utilitarelor matematice.
• Un ghid practic pentru lucrul cu fiecare format 3D suportat – OBJ, STL, glTF și FBX – incluzând opțiuni de încărcare/salvare și modele de conversie în lot.

Rămâneți conectați și nu ezitați să explorați biblioteca și să împărtășiți feedback-ul dumneavoastră pe GitHub.