Introducerar Aspose.3D FOSS för Java

Vi är glada att meddela tillgängligheten av Aspose.3D FOSS för Java – ett fritt, öppen källkod-bibliotek för att arbeta med 3D‑filformat i Java-applikationer. Byggt som en ren Java-lösning utan inhemska beroenden, kör biblioteket på Java 21 och senare, vilket gör det tillgängligt för ett brett spektrum av projekt och miljöer.

Detta inlägg går igenom vad biblioteket erbjuder, hur du kommer igång och vart du kan gå härifrån.

Vad är Aspose.3D FOSS för Java?

Aspose.3D FOSS för Java är ett lättviktigt 3D‑filbehandlingsbibliotek publicerat under MIT-licens. Den tillhandahåller ett scene‑graph‑API som låter dig läsa in, inspektera, transformera och spara 3D-modeller över flera allmänt använda format. Biblioteket är helt skrivet i Java och kräver inga externa inhemska binärer eller plattforms‑specifika konfigurationer.

Källkoden finns tillgänglig på GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Viktiga höjdpunkter

• Ren Java – ingen JNI, inga inhemska bibliotek, inga plattformsrestriktioner.
• Java 21+ kompatibel.
• MIT-licensierad – använd den i personliga, kommersiella eller proprietära projekt utan restriktioner.
• Scengraf-arkitektur – ett bekant träd av noder, meshar, kameror och material.
• Stöd för flera format – läs och skriv OBJ-, STL-, glTF 2.0- och GLB-filer; läs FBX-filer.

Snabbstart

Maven-installation

Lägg till följande beroende i din pom.xml:

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

Din första konvertering

Det enklaste användningsfallet är att läsa in en 3D-fil i ett format och spara den i ett annat. Här är en två‑raders konvertering från OBJ till 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");
    }
}

Den Scene class är den centrala ingångspunkten. Anropa Scene.fromFile() med en filsökväg för att ladda en modell, och sedan anropa save() med målvägen. Biblioteket härleder formatet från filändelsen.

Bygga en scen från grunden

Du kan också konstruera scener programatiskt:

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

Detta skapar en ny scen, lägger till en barnnod med namnet “Box” under roten, placerar den på koordinaterna (1, 2, 3) och exporterar resultatet som en glTF-fil.

Laddning med format‑specifika alternativ

När du behöver finare kontroll över inläsningsprocessen erbjuder varje format en dedikerad alternativklass. Till exempel, att ladda en STL‑fil med explicita alternativ:

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

Den Scene.fromFile() statisk metod accepterar någon av laddningsalternativstyperna: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, eller FbxLoadOptions.

Traversering av scen‑grafen

När en scen har laddats kan du gå igenom nodträdet för att inspektera eller ändra dess innehåll:

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

Detta mönster är användbart för felsökning, generering av rapporter om modellens innehåll eller för att selektivt modifiera delar av en scen innan den återexporteras.

Tillämpa transformationer

Positionering av noder i 3D-rymden görs via Transform objekt på varje 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");
    }
}

Transformationer följer den standardiserade föräldra-barn-arvmodellen: ett barns världsrumsposition är kombinationen av dess lokala transformation och alla förfäders transformationer upp till roten.

Vad som ingår

Biblioteket levereras med en fokuserad uppsättning funktioner utformade kring 3D-scengrafmodellen.

Scengraf

Scengrafen är ryggraden i API:et. Varje 3D-fil representeras som en trädstruktur:

Material

Biblioteket tillhandahåller en PBR (Physically Based Rendering) materialmodell:

• PbrMaterial – fysiskt baserat renderingsmaterial med albedo, metalness, roughness, emissiv färg och transparens. Detta är den enda konkreta materialklassen som finns i Java-utgåvan.

Matematikverktyg

Den com.aspose.threed paketet innehåller grundläggande matematiska primitiv:

• Vector3 – 3-komponentsvektor för positioner, riktningar och färger.
• Matrix4 – 4x4 transformationsmatris.
• Quaternion – rotationsrepresentation.
• BoundingBox – axeljusterad avgränsningsbox för rumsliga frågor.

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

Läs- och sparaalternativ

Varje format har dedikerade alternativklasser som låter dig styra import- och exportbeteende:

Till exempel, för att exportera glTF med snyggt formaterad JSON och ett omvänt koordinatsystem:

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

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

Stödda format

Följande tabell sammanfattar de format som Aspose.3D FOSS för Java kan läsa och skriva.

OBJ, STL, glTF och GLB stödjer både inläsning och sparande. FBX stöds endast för import.

Guide för formatval

Att välja rätt format beror på ditt användningsområde:

• OBJ är ideal när du behöver maximal kompatibilitet över 3D-verktyg. Nästan alla modelleringsprogram kan läsa och skriva OBJ. Det fungerar bra för utbyte av mesh-data men innehåller endast grundläggande materialinformation via medföljande MTL-filer.
• STL är det föredragna formatet för 3D-utskriftsarbetsflöden. Det lagrar rå triangulerad geometri utan material eller scenhierarki, vilket exakt är vad slicer‑programvara förväntar sig. Om din pipeline slutar vid en 3D‑skrivare är STL det enkla valet.
• glTF är den moderna standarden för webb och realtids‑3D. Den stöder PBR‑material, fullständiga scenhierarkier och är utformad för effektiv överföring. Använd glTF när du bygger webbaserade visare, arbetar med three.js eller Babylon.js, eller riktar dig mot någon realtidsrenderingspipeline.
• FBX är djupt integrerad i spelutveckling och arbetsflöden för digitalt innehållsskapande. Den stöder rik sceninformation inklusive hierarkier och material. Aspose.3D FOSS för Java stöder FBX endast import – använd den för att ladda FBX‑tillgångar och konvertera dem till andra format.

Kända begränsningar

Det är viktigt att notera att Scene.render() är stöds inte i FOSS-utgåvan. Att anropa den här metoden kommer att kasta ett UnsupportedOperationException. Biblioteket är utformat för filbaserad 3D-behandling – inläsning, manipulering, transformation och sparande av modeller – snarare än realtidsrendering till en skärm.

Öppen källkod och licensiering

Aspose.3D FOSS för Java släpps under MIT License. Detta betyder att du är fri att:

• Använd biblioteket i kommersiella och proprietära applikationer.
• Modifiera källkoden för att passa dina behov.
• Distribuera biblioteket som en del av din egen programvara.

Det finns inga royaltyavgifter, inga användningsgränser och inga krav på erkännande utöver vad MIT-licensen specificerar.

Den fullständiga källkoden är hostad på GitHub, och bidrag är välkomna: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Systemkrav

Komma igång

Här är resurserna som hjälper dig att komma igång:

• Dokumentation – omfattande guider och API-genomgångar finns tillgängliga på Aspose.3D dokumentationssida.
• Kunskapsbas – praktiska hur-man-gör-artiklar och felsökningstips i Aspose.3D KB.
• API-referens – detaljerad klass- och metodreferens på Aspose.3D API-referens.
• Källkod – bläddra och bidra på GitHub.
• Maven Central – paketet publiceras som com.aspose:aspose-3d-foss på Maven Central.

Vanliga användningsfall

Här är några praktiska scenarier där Aspose.3D FOSS för Java passar bra:

Formatkonverteringspipelines

Många team får 3D‑tillgångar i ett format men behöver dem i ett annat. Ett designteam kan arbeta i FBX medan webbteamet behöver glTF. Biblioteket låter dig bygga automatiserade konverteringspipelines:

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

Innan du integrerar en 3D‑resurs i din applikation kan du vilja validera dess innehåll – kontrollera nodantal, verifiera geometri eller bekräfta att förväntade element finns:

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

Scensammansättning

Du kan ladda flera modeller och kombinera dem till en enda 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");

Vad kommer härnäst

I kommande inlägg kommer vi att behandla:

• En djupdykning i nyckelfunktionerna i scene-graph API, material och matematiska verktyg.
• En praktisk guide för att arbeta med varje stödd 3D‑format – OBJ, STL, glTF och FBX – inklusive laddnings-/sparalternativ och batchkonverteringsmönster.

Håll utkik, och känn dig fri att utforska biblioteket och dela din feedback på GitHub.