Introduksjon av Aspose.3D FOSS for Java

Vi er glade for å kunngjøre tilgjengeligheten av Aspose.3D FOSS for Java – et gratis, åpen kildekode-bibliotek for å arbeide med 3D-filformater i Java-applikasjoner. Bygget som en ren Java-løsning uten native avhengigheter, kjører biblioteket på Java 21 og senere, noe som gjør det tilgjengelig for et bredt spekter av prosjekter og miljøer.

Dette innlegget går gjennom hva biblioteket tilbyr, hvordan du kommer i gang, og hvor du kan gå videre herfra.

Hva er Aspose.3D FOSS for Java?

Aspose.3D FOSS for Java er et lettvektig 3D-filbehandlingsbibliotek publisert under MIT-lisens. Den gir et scene-graph API som lar deg laste, inspisere, transformere og lagre 3D-modeller på tvers av flere mye brukte formater. Biblioteket er helt skrevet i Java og krever ingen eksterne native binærfiler eller plattformspesifikke konfigurasjoner.

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

Viktige høydepunkter

• Ren Java – ingen JNI, ingen native biblioteker, ingen plattformrestriksjoner.
• Java 21+ kompatibel.
• MIT-licensiert – bruk den i personlige, kommersielle eller proprietære prosjekter uten restriksjoner.
• Scene-graph-arkitektur – et kjent tre av noder, mesh-objekter, kameraer og materialer.
• Støtte for flere formater – les og skriv OBJ, STL, glTF 2.0, og GLB-filer; les FBX-filer.

Rask start

Maven‑installasjon

Legg til følgende avhengighet i ditt pom.xml:

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

Din første konvertering

Det enkleste bruksområdet er å laste inn en 3D‑fil i ett format og lagre den i et annet. Her er en to‑linjes 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 class er hovedinngangspunktet. Kall Scene.fromFile() med en filsti for å laste inn en modell, deretter kall save() med målstien. Biblioteket infererer formatet fra filendelsen.

Bygge en scene fra bunnen av

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 oppretter en ny scene, legger til en undernode kalt “Box” under roten, plasserer den på koordinatene (1, 2, 3), og eksporterer resultatet som en glTF‑fil.

Lasting med formatspesifikke alternativer

Når du trenger finere kontroll over lasteprosessen, gir hvert format en dedikert alternativklasse. For eksempel, lasting av en STL‑fil med eksplisitte alternativer:

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 aksepterer noen av lastalternativ-typene: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, eller FbxLoadOptions.

Traversering av scenegrafen

Når en scene er lastet, kan du gå gjennom nodetreet for å inspisere eller endre innholdet:

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ønsteret er nyttig for feilsøking, generering av rapporter om modellinnhold, eller selektiv modifisering av deler av en scene før re‑eksport.

Anvendelse av transformasjoner

Posisjonering av noder i 3D-rom utføres gjennom 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");
    }
}

Transformasjoner følger den standard foreldre‑barn arve‑modellen: et barns world‑space‑posisjon er kombinasjonen av dens lokale transformasjon og alle forfedrenes transformasjoner opp til roten.

Hva som er inkludert

Biblioteket leveres med et fokusert sett av funksjoner designet rundt 3D scene‑graph‑modellen.

Scene‑graf

Scene‑grafen er ryggraden i API‑et. Hver 3D‑fil er representert som en trestruktur:

Materialer

Biblioteket tilbyr en PBR (Physically Based Rendering) materialmodell:

• PbrMaterial – fysisk basert renderingsmateriale med albedo, metallitet, ruhet, emissiv farge og gjennomsiktighet. Dette er den eneste konkrete materialklassen som er tilgjengelig i Java-utgaven.

Matematikkverktøy

Den com.aspose.threed pakken inkluderer essensielle matematiske primitive:

• Vector3 – 3-komponent vektor for posisjoner, retninger og farger.
• Matrix4 – 4x4 transformasjonsmatrise.
• Quaternion – rotasjonsrepresentasjon.
• BoundingBox – aksejustert avgrensningsboks for romlige spørringer.

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

Last inn og lagre-alternativer

Hvert format har dedikerte alternativklasser som lar deg kontrollere import- og eksportatferd:

For eksempel, for å eksportere glTF med pent formatert JSON og et vendt koordinatsystem:

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

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

Støttede formater

Tabellen nedenfor oppsummerer formatene som Aspose.3D FOSS for Java kan lese og skrive.

OBJ, STL, glTF og GLB støtter både innlasting og lagring. FBX støttes kun for import.

Veiledning for valg av format

Valg av riktig format avhenger av ditt brukstilfelle:

• OBJ er ideelt når du trenger maksimal kompatibilitet på tvers av 3D-verktøy. Nesten alle modelleringsprogrammer kan lese og skrive OBJ. Det fungerer bra for utveksling av mesh-data, men inneholder kun grunnleggende materialinformasjon via tilhørende MTL-filer.
• STL er formatet som foretrekkes i 3D‑utskriftsarbeidsflyter. Det lagrer rå triangulert geometri uten materialer eller scenehierarki, noe som er akkurat det slicer‑programvaren forventer. Hvis arbeidsflyten din ender ved en 3D‑printer, er STL det enkle valget.
• glTF er den moderne standarden for web og sanntids‑3D. Den støtter PBR‑materialer, fullstendige scenehierarkier, og er designet for effektiv overføring. Bruk glTF når du bygger nettbaserte visere, arbeider med three.js eller Babylon.js, eller retter deg mot enhver sanntids‑renderings‑pipeline.
• FBX er dypt integrert i spillutvikling og arbeidsflyter for digital innholdsproduksjon. Den støtter rik scenedata inkludert hierarkier og materialer. Aspose.3D FOSS for Java støtter FBX kun import – bruk den til å laste inn FBX‑ressurser og konvertere dem til andre formater.

Kjente begrensninger

Det er viktig å merke seg at Scene.render() er støttes ikke i FOSS-utgaven. Å kalle denne metoden vil kaste en UnsupportedOperationException. Biblioteket er designet for filbasert 3D-behandling – lasting, manipulering, transformering og lagring av modeller – snarere enn sanntidsrendering til en skjerm.

Åpen kilde og lisensiering

Aspose.3D FOSS for Java er utgitt under MIT License. Dette betyr at du er fri til å:

• Bruke biblioteket i kommersielle og proprietære applikasjoner.
• Modifisere kildekoden for å passe dine behov.
• Distribuer biblioteket som en del av din egen programvare.

Det er ingen royalty‑gebyrer, ingen bruksbegrensninger, og ingen krav til kreditering utover det MIT‑lisensen spesifiserer.

Den fullstendige kildekoden 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 ressursene som hjelper deg i gang:

• Dokumentasjon – omfattende guider og API-gjennomganger er tilgjengelige på the Aspose.3D dokumentasjonsnettsted.
• Kunnskapsbase – praktiske hvordan‑gjør‑det‑artikler og feilsøkingstips i the Aspose.3D KB.
• API-referanse – detaljert klasse- og metode-referanse på the Aspose.3D API-referanse.
• Kildekode – bla gjennom og bidra på GitHub.
• Maven Central – pakken er publisert som com.aspose:aspose-3d-foss på Maven Central.

Vanlige bruksområder

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

Formatkonverterings‑pipelines

Mange team mottar 3D‑ressurser i ett format, men trenger dem i et annet. Et designteam kan jobbe i FBX, mens webteamet trenger glTF. Biblioteket lar deg bygge automatiserte 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‑ressurs i applikasjonen din, kan det være lurt å validere innholdet – sjekke antall noder, verifisere geometrien, eller bekrefte at 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‑sammensetting

Du kan laste inn 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");

Hva blir neste

I kommende innlegg vil vi dekke:

• En grundig gjennomgang av nøkkelfunksjonene i scene‑graf‑API‑et, materialer og matematiske verktøy.
• En praktisk veiledning for å arbeide med hvert støttede 3D‑format – OBJ, STL, glTF og FBX – inkludert last/save‑alternativer og mønstre for batch‑konvertering.

Følg med, og føl deg fri til å utforske biblioteket og dele tilbakemeldingene dine på GitHub.