Predstavujeme Aspose.3D FOSS pre Java

S radosťou oznamujeme dostupnosť Aspose.3D FOSS for Java – bezplatná, open-source knižnica na prácu s 3D formátmi súborov v Java aplikáciách. Vytvorená ako čisté riešenie Java bez natívnych závislostí, knižnica beží na Java 21 a novších, čo ju robí prístupnou pre širokú škálu projektov a prostredí.

Tento príspevok prechádza tým, čo knižnica ponúka, ako začať a kam sa ďalej vydať.

Čo je Aspose.3D FOSS pre Java?

Aspose.3D FOSS for Java je ľahká knižnica na spracovanie 3D súborov publikovaná pod the MIT license. Poskytuje API pre scénový graf, ktoré vám umožní načítať, kontrolovať, transformovať a ukladať 3D modely v rôznych široko používaných formátoch. Knižnica je úplne napísaná v Java a nevyžaduje žiadne externé natívne binárne súbory ani špecifické konfigurácie platformy.

Zdrojový kód je dostupný na GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Kľúčové body

• Čistý Java – žiadne JNI, žiadne natívne knižnice, žiadne obmedzenia platformy.
• Java 21+ kompatibilný.
• licencované pod MIT – použite ho v osobných, komerčných alebo proprietárnych projektoch bez obmedzení.
• architektúra grafu scény – známy strom uzlov, sietí, kamier a materiálov.
• Podpora viacerých formátov – čítať a zapisovať súbory OBJ, STL, glTF 2.0 a GLB; čítať súbory FBX.

Rýchly štart

Inštalácia Maven

Pridajte nasledujúcu závislosť do svojho pom.xml:

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

Vaša prvá konverzia

Najjednoduchší prípad použitia je načítanie 3D súboru v jednom formáte a jeho uloženie v inom. Tu je dvojriadková konverzia z OBJ do 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");
    }
}

Ten Scene class je centrálny vstupný bod. Zavolajte Scene.fromFile() s file path na načítanie modelu, potom zavolajte save() s cieľovou cestou. Knižnica odvodí formát z prípony súboru.

Vytváranie scény od začiatku

Scény môžete tiež programovo zostaviť:

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

Toto vytvorí novú scénu, pridá pod koreňový uzol poduzol s názvom “Box”, umiestni ho na súradnice (1, 2, 3) a exportuje výsledok ako súbor glTF.

Načítanie s formátovo špecifickými možnosťami

Keď potrebujete jemnejšiu kontrolu nad procesom načítania, každý formát poskytuje samostatnú triedu možností. Napríklad načítanie STL súboru s explicitnými možnosťami:

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() statická metóda akceptuje ktorýkoľvek z typov možností načítania: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, alebo FbxLoadOptions.

Prechádzanie grafom scény

Akonáhle je scéna načítaná, môžete prechádzať strom uzlov a kontrolovať alebo upravovať jeho obsah:

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

Tento vzor je užitočný na ladenie, generovanie správ o obsahu modelu alebo selektívne upravovanie častí scény pred opätovným exportom.

Aplikovanie transformácií

Umiestňovanie uzlov v 3D priestore sa vykonáva prostredníctvom Transform objektu na každom 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ácie nasledujú štandardný model dedičnosti rodič‑dieťa: pozícia dieťaťa vo svetovom priestore je kombináciou jeho lokálnej transformácie a všetkých transformácií predkov až po koreň.

Čo je zahrnuté

Knižnica je dodávaná so zameranou sadou funkcií navrhnutých okolo modelu 3D scény grafu.

Scénový graf

Scénový graf je chrbticou API. Každý 3D súbor je reprezentovaný ako stromová štruktúra:

Materiály

Knižnica poskytuje PBR (Physically Based Rendering) model materiálu:

• PbrMaterial – materiál založený na fyzickom renderovaní s albedom, kovitosťou, drsnosťou, emisnou farbou a priehľadnosťou. Toto je jedinečná konkrétna trieda materiálu dostupná v edícii Java.

Matematické nástroje

Ten com.aspose.threed balík obsahuje základné matematické primitívy:

• Vector3 – 3‑komponentový vektor pre pozície, smerovanie a farby.
• Matrix4 – 4x4 transformačná matica.
• Quaternion – reprezentácia rotácie.
• BoundingBox – osovo zarovnaná ohraničujúca krabica pre priestorové dotazy.

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

Možnosti načítania a ukladania

Každý formát má špeciálne triedy možností, ktoré vám umožňujú ovládať správanie importu a exportu:

Napríklad, na export glTF s pekne formátovaným JSON a prevráteným súradnicovým systémom:

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

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

Podporované formáty

Nasledujúca tabuľka zhrňuje formáty, ktoré Aspose.3D FOSS pre Java dokáže čítať a zapisovať.

OBJ, STL, glTF a GLB podporujú načítanie aj ukladanie. FBX je podporovaný iba pre import.

Sprievodca výberom formátu

Výber správneho formátu závisí od vášho použitia:

• OBJ je ideálny, keď potrebujete maximálnu kompatibilitu naprieč 3D nástrojmi. Takmer každá modelovacia aplikácia dokáže čítať a zapisovať OBJ. Funguje dobre pre výmenu sieťových dát, ale prenáša iba základné informácie o materiáloch prostredníctvom sprievodných MTL súborov.
• STL je formátom voľby pre workflow 3D tlače. Ukladá surovú triangulovanú geometriu bez materiálov alebo hierarchie scény, čo je presne to, čo očakáva slicer softvér. Ak váš proces končí pri 3D tlačiarni, STL je jednoduchá voľba.
• glTF je moderným štandardom pre web a real‑time 3D. Podporuje PBR materiály, úplné hierarchie scény a je navrhnutý pre efektívny prenos. Používajte glTF pri tvorbe webových prehliadačov, práci s three.js alebo Babylon.js, alebo pri cielení na akýkoľvek real‑time renderovací pipeline.
• FBX je hlboko integrovaný do pracovných postupov vývoja hier a tvorby digitálneho obsahu. Podporuje bohaté dáta scény vrátane hierarchií a materiálov. Aspose.3D FOSS pre Java podporuje FBX iba import – použite ho na načítanie FBX aktív a ich konverziu do iných formátov.

Známe obmedzenia

Je dôležité poznamenať, že Scene.render() je nie je podporované v edícii FOSS. Zavolaním tejto metódy bude vyvolaná UnsupportedOperationException. Knižnica je navrhnutá pre súborovo založené 3D spracovanie – načítanie, manipuláciu, transformáciu a ukladanie modelov – namiesto renderovania v reálnom čase na displej.

Open Source a licencovanie

Aspose.3D FOSS pre Java je vydaný pod MIT License. To znamená, že môžete:

• Používať knižnicu v komerčných a proprietárnych aplikáciách.
• Upraviť zdrojový kód podľa svojich potrieb.
• Distribujte knižnicu ako súčasť vášho vlastného softvéru.

Neexistujú žiadne licenčné poplatky, žiadne obmedzenia používania a žiadne požiadavky na atribúciu okrem toho, čo špecifikuje licencia MIT.

Úplný zdrojový kód je hostovaný na GitHub-e a príspevky sú vítané: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Systémové požiadavky

Začíname

Tu sú zdroje, ktoré vám pomôžu začať:

• Dokumentácia – komplexné príručky a prechody API sú k dispozícii na Aspose.3D dokumentačná stránka.
• Znalostná báza – praktické návody a tipy na riešenie problémov v Aspose.3D KB.
• Referenčná dokumentácia API – podrobná referencia tried a metód na Aspose.3D API referencie.
• Zdrojový kód – prehliadať a prispievať na GitHub.
• Maven Central – balík je publikovaný ako com.aspose:aspose-3d-foss na Maven Central.

Bežné prípady použitia

Tu je niekoľko praktických scenárov, kde Aspose.3D FOSS pre Java dobre zapadá:

Potrubia konverzie formátov

Mnoho tímov dostáva 3D aktíva v jednom formáte, ale potrebuje ich v inom. Dizajnový tím môže pracovať s FBX, zatiaľ čo webový tím potrebuje glTF. Knižnica vám umožňuje vytvárať automatizované potrubia konverzie:

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

Pred integráciou 3D aktíva do vašej aplikácie môžete chcieť overiť jeho obsah – kontrolovať počet uzlov, overovať geometriu alebo potvrdiť, že očakávané prvky sú prítomné:

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

Zostavenie scény

Môžete načítať viacero modelov a skombinovať ich do jednej scény:

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

Čo ďalej

V nasledujúcich príspevkoch sa budeme venovať:

• Hlboký ponor do kľúčových funkcií API scény‑grafu, materiálov a matematických nástrojov.
• Praktický sprievodca prácou s každým podporovaným 3D formátom – OBJ, STL, glTF a FBX – vrátane možností načítania/ukladania a vzorov hromadnej konverzie.

Zostaňte naladení a neváhajte preskúmať knižnicu a zdieľať svoju spätnú väzbu na GitHub-e.