Introducerer Aspose.3D FOSS for Java

Vi er begejstrede for at annoncere tilgængeligheden af Aspose.3D FOSS til Java – et gratis, open source-bibliotek til at arbejde med 3D-filformater i Java-applikationer. Bygget som en ren Java-løsning uden native afhængigheder, kører biblioteket på Java 21 og senere, hvilket gør det tilgængeligt for et bredt udvalg af projekter og miljøer.

Dette indlæg gennemgår, hvad biblioteket tilbyder, hvordan du kommer i gang, og hvor du kan gå videre herfra.

Hvad er Aspose.3D FOSS for Java?

Aspose.3D FOSS til Java er et letvægts 3D-filbehandlingsbibliotek udgivet under den MIT license. Den leverer et scene‑graph‑API, der lader dig indlæse, inspicere, transformere og gemme 3D-modeller på tværs af flere udbredte formater. Biblioteket er fuldstændigt skrevet i Java og kræver ingen eksterne native binære filer eller platformspecifikke konfigurationer.

Kildekoden er tilgængelig på GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Vigtige højdepunkter

• Ren Java – ingen JNI, ingen native biblioteker, ingen platformbegrænsninger.
• Java 21+ kompatibel.
• MIT-licenseret – brug den i personlige, kommercielle eller proprietære projekter uden begrænsninger.
• Scene-graph-arkitektur – et velkendt træ af noder, mesh’er, kameraer og materialer.
• Understøttelse af flere formater – læs og skriv OBJ, STL, glTF 2.0 og GLB-filer; læs FBX-filer.

Hurtig start

Maven-installation

Tilføj følgende afhængighed til din pom.xml:

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

Din første konvertering

Den enkleste brugssag er at indlæse en 3D-fil i ét format og gemme den i et andet. Her er en to‑linjers konvertering fra OBJ til 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 klassen er det centrale indgangspunkt. Kald Scene.fromFile() med en filsti for at indlæse en model, og derefter kald save() med målstien. Biblioteket udleder formatet ud fra filendelsen.

Opbygning af en Scene fra bunden

Du kan også konstruere scener programmatisk:

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

Dette opretter en ny scene, tilføjer en undernode med navnet “Box” under roden, placerer den på koordinaterne (1, 2, 3) og eksporterer resultatet som en glTF-fil.

Indlæsning med format‑specifikke indstillinger

Når du har brug for finere kontrol over indlæsningsprocessen, tilbyder hvert format en dedikeret options‑klasse. For eksempel, indlæsning af en STL‑fil med eksplicitte indstillinger:

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 metode accepterer enhver af indlæsningsindstillings-typerne: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, eller FbxLoadOptions.

Traversering af scene‑grafen

Når en scene er indlæst, kan du gå gennem nodetræet for at inspicere eller ændre dets indhold:

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

Dette mønster er nyttigt til fejlfinding, generering af rapporter om modellens indhold eller selektiv ændring af dele af en scene inden gen‑eksport.

Anvendelse af transformationer

Placering af noder i 3D-rum udføres via Transform objekt på hver 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ølger den standard forældre‑barn arvemodel: et barns verdensrum‑position er kombinationen af dets lokale transformation og alle forfædres transformationer op til roden.

Hvad der er inkluderet

Biblioteket leveres med et fokuseret sæt af funktioner designet omkring 3D‑scengraf‑modellen.

Scengraf

Scengrafen er rygraden i API’et. Hver 3D‑fil repræsenteres som en træstruktur:

Materialer

Biblioteket leverer en PBR (Physically Based Rendering) materialmodel:

• PbrMaterial – fysisk baseret rendering-materiale med albedo, metalness, roughness, emissiv farve og gennemsigtighed. Dette er den eneste konkrete materialeklasse tilgængelig i Java-udgaven.

Matematikværktøjer

Den com.aspose.threed pakken indeholder essentielle matematiske primitive:

• Vector3 – 3-komponent vektor til positioner, retninger og farver.
• Matrix4 – 4x4 transformationsmatrix.
• Quaternion – rotationsrepræsentation.
• BoundingBox – aksejusteret begrænsningsboks til rumlige forespørgsler.

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

Indlæsnings- og gemmeindstillinger

Hvert format har dedikerede optionsklasser, der giver dig mulighed for at styre import- og eksportadfærd:

For eksempel, for at eksportere glTF med pænt formateret JSON og et vendt koordinatsystem:

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

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

Understøttede formater

Den følgende tabel opsummerer de formater, som Aspose.3D FOSS for Java kan læse og skrive.

OBJ, STL, glTF og GLB understøtter både indlæsning og gemning. FBX understøttes kun for import.

Vejledning til formatvalg

Valg af det rigtige format afhænger af din anvendelse:

• OBJ er ideel, når du har brug for maksimal kompatibilitet på tværs af 3D‑værktøjer. Næsten alle modelleringsprogrammer kan læse og skrive OBJ. Den fungerer godt til udveksling af mesh‑data, men overfører kun grundlæggende materialinformation via tilhørende MTL‑filer.
• STL er det foretrukne format til 3D‑printarbejdsprocesser. Det gemmer rå trianguleret geometri uden materialer eller scenehierarki, hvilket er præcis, hvad slicer‑software forventer. Hvis din pipeline ender ved en 3D‑printer, er STL det ligefremme valg.
• glTF er den moderne standard for web og realtids‑3D. Den understøtter PBR-materialer, fulde scenehierarkier og er designet til effektiv transmission. Brug glTF, når du bygger web‑baserede visningsprogrammer, arbejder med three.js eller Babylon.js, eller målretter enhver realtids‑renderings‑pipeline.
• FBX er dybt integreret i spiludvikling og arbejdsgange for digital indholdsoprettelse. Den understøtter rige scenedata inklusive hierarkier og materialer. Aspose.3D FOSS for Java understøtter FBX kun import – brug den til at indlæse FBX‑aktiver og konvertere dem til andre formater.

Kendte begrænsninger

Det er vigtigt at bemærke, at Scene.render() er understøttes ikke i FOSS-udgaven. Kald af denne metode vil kaste en UnsupportedOperationException. Biblioteket er designet til filbaseret 3D-behandling – indlæsning, manipulation, transformation og gemning af modeller – snarere end realtidsrendering til en skærm.

Open source og licensering

Aspose.3D FOSS for Java er udgivet under den MIT License. Det betyder, at du er fri til at:

• Bruge biblioteket i kommercielle og proprietære applikationer.
• Modificere kildekoden, så den passer til dine behov.
• Distribuer biblioteket som en del af din egen software.

Der er ingen royaltygebyrer, ingen brugsbegrænsninger og ingen krav om kreditering ud over, hvad MIT-licensen specificerer.

Den komplette kildekode er hostet på GitHub, og bidrag er velkomne: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Systemkrav

Kom i gang

Her er ressourcerne, der hjælper dig i gang:

• Dokumentation – omfattende guider og API-gennemgange er tilgængelige på Aspose.3D dokumentationsside.
• Videnbase – praktiske how-to-artikler og fejlfindingstips i Aspose.3D KB.
• API-reference – detaljeret klasse- og metode-reference på Aspose.3D API-reference.
• Kildekode – gennemse og bidrag på GitHub.
• Maven Central – pakken er udgivet som com.aspose:aspose-3d-foss på Maven Central.

Almindelige anvendelsestilfælde

Her er nogle praktiske scenarier, hvor Aspose.3D FOSS for Java passer godt:

Formatkonverterings‑pipelines

Mange teams modtager 3D‑assets i ét format, men har brug for dem i et andet. Et designteam kan arbejde i FBX, mens webteamet har brug for glTF. Biblioteket giver dig mulighed for at bygge automatiserede konverterings‑pipelines:

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

Før du integrerer en 3D‑ressource i din applikation, vil du måske validere dens indhold – kontrollere antallet af noder, verificere geometrien eller bekræfte, at de forventede elementer er til stede:

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

Scene-samling

Du kan indlæse flere modeller og kombinere dem til en enkelt scene:

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

Hvad er næste

I kommende indlæg vil vi dække:

• En dybdegående gennemgang af nøglefunktionerne i scene‑graf‑API’en, materialer og matematik‑værktøjer.
• En praktisk guide til at arbejde med hvert understøttet 3D‑format – OBJ, STL, glTF og FBX – inklusive indlæsnings-/gemme‑muligheder og batch‑konverteringsmønstre.

Hold dig opdateret, og føl dig fri til at udforske biblioteket og dele din feedback på GitHub.