Introductie Aspose.3D FOSS voor Java

Wij zijn blij om de beschikbaarheid van Aspose.3D FOSS voor Java - een gratis, open-source bibliotheek voor het werken met 3D bestandformaat in Java toepassingen. gebouwd als een pure Java oplossing zonder native afhankelijkheden, de bibliothetiek loopt op Java 21 en later, waardoor het toegankelijk is voor een breed scala van projecten en omgevingen.

Dit bericht gaat door wat de bibliotheek biedt, hoe te beginnen en waar te gaan van hier.

Wat is de 3D FOSS voor Java?

Aspose.3D FOSS voor Java is een lichtgewicht 3D bestandverwerking bibliotheek gepubliceerd onder de Mijn licentie.Het biedt een scène-graph API die u toelaat om 3D modellen te laden, inspecteren, transformeren en opslaan in verschillende veelgebruikte formaten.De bibliotheek is volledig geschreven in Java en vereist geen externe native binaries of platformspecifieke configuraties.

De broncode is beschikbaar op GitHub: HTTPS://github.com/aspose-3d-foss/Aspose.3D-FOSS-voor Java

Key Highlights

• De pure Java - geen JNI, geen inheemse bibliotheken, niet platformbeperkingen.
• Java 21+ compatibel zijn.
• MIT geautoriseerd - het gebruiken in persoonlijke, commerciële of eigendomsvoorzieningen zonder beperkingen.
• Scene-graph architectuur - een bekende boom van knooppunten, mesjes, camera’s en materialen.
• Multi-formaat ondersteuning - lees en schrijf OBJ, STL, glTF 2.0 en GLB bestanden; lees FBX bestanddelen.

Snelle start

Maven installatie

Voeg de volgende afhankelijkheid toe aan uw pom.xml:

<dependency>
  <groupId>org.aspose</groupId>
  <artifactId>aspose-3d-foss</artifactId>
  <version>26.5.0</version>
</dependency>

Uw eerste conversie

Het eenvoudigste gebruik is om een 3D-bestand in één format te laden en het in een ander te besparen. hier is een tweelijnconversie van OBJ naar 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");
    }
}

De The Scene De klas is het centrale ingangpunt.Call Scene.fromFile() met een bestandpad om een model te laden, dan bellen save() met de doelpad.De bibliotheek infereert het format uit de bestanduitbreiding.

Een scène van Scratch maken

Je kunt ook scènes programmeren:

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

Dit creëert een nieuwe scène, voegt onder de wortel een kinderknop genaamd “Box” toe, zet het in coördinaten (1, 2, 3), en exporteert het resultaat als een glTF-bestand.

Loading met Format-Specifieke Opties

Wanneer u een beter beheer over het loadingproces nodig heeft, biedt elk formaat een gespecialiseerde optiesklasse. Bijvoorbeeld, het laden van een STL-bestand met uitdrukkelijke optie:

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

De The Scene.fromFile() de statische methode accepteert een van de optie typen: ObjLoadOptions, StlLoadOptions, GltfLoadOptions,Of FbxLoadOptions.

Door de Scene Graph

Zodra een scène is geladen, kunt u de knopbomen lopen om zijn inhoud te controleren of te wijzigen:

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

Dit patroon is nuttig voor de afbreuk, het genereren van rapporten over modelinhoud of selectief delen van een scène te wijzigen voordat ze opnieuw worden uitgevoerd.

Transformatie toepassen

Positionering van knooppunten in 3D-ruimte wordt gedaan door middel van de Transform object op elk van de 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");
    }
}

Transformes volgen het standaard oud-kind erfgoedmodel: de wereldruimtepositie van een kind is de combinatie van zijn lokale transformatie en alle voorouders veranderen tot aan de wortel.

Wat is opgenomen

De bibliotheek schepen met een geconcentreerd set van mogelijkheden ontworpen rond het 3D scène-graph model.

Scène grafiek

Het scène-graaf is de achtergrond van het API. Elk 3D-bestand wordt vertegenwoordigd als een boomstructuur:

Materialen

De bibliotheek biedt een PBR (Physically Based Rendering) materiaalmodel:

• PbrMaterial - fysiek gebaseerd rendering materiaal met albedo, metalliciteit, roosheid, emissieve kleur en transparantie. dit is de enige concrete materiële klasse beschikbaar in de Java-editie.

Mathe Utiliteiten

De The com.aspose.threed Het pakket bevat essentiële wiskundige primitiven:

• Vector 3 - 3-component vector voor posities, richtingen en kleuren.
• Matrix 4 4x4 transformatie matrix.
• Quaternie De rotatie representatie.
• BoundingBox - axis-aligned boundbox voor ruimtelijke vragen.

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

Load en Save opties

Elk format heeft gespecialiseerde optiesklassen die u toelaten om het invoer en export gedrag te controleren:

Bijvoorbeeld, om glTF te exporteren met een vrij gedrukte JSON en een flinke coördinatenysteem:

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

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

Ondersteunde formaten

De volgende tabel verzamelt de formaten die Aspose.3D FOSS voor Java kan lezen en schrijven.

OBJ, STL, glTF en GLB ondersteunen zowel loading als besparing. FBX wordt alleen voor invoer ondersteund.

Format Selectie Guide

Het kiezen van het juiste formaat hangt af van uw gebruik:

• OBJ is ideaal wanneer u maximale compatibiliteit nodig heeft tussen 3D-tools. Bijna elke modelaatprogramma kan OBJ lezen en schrijven. Het werkt goed voor het uitwisselen van mesh gegevens maar brengt alleen de basismateriële informatie door middel van companion MTL bestanden.
• STL Het opslaat grondige triangulaire geometrie zonder materialen of scène hiërarchie, wat precies is wat slicer software verwacht. Als uw pijpleid eindigt met een 3D printer, STL is de eenvoudige keuze.
• GTTF is de moderne standaard voor web en real-time 3D. Het ondersteunt PBR materialen, volledige scène hiërarchieën, en is ontworpen voor efficiënt overdracht. Gebruik glTF bij het bouwen van webgebaseerde kijkers, werken met three.js of Babylon.js, of gericht op elke realtime rendering pipeline.
• FBX is diep geïntegreerd in game development en digitale content creatie werkstromen. het ondersteunt rijke scène gegevens, waaronder hiërarchieën en materialen. Aspose.3D FOSS voor Java ondersteund FBX Alleen invoer - gebruik het om FBX-activa te laden en ze in andere formaten te converteren.

Bekende beperkingen

Het is belangrijk om te merken dat Scene.render() is niet ondersteund in de FOSS-editie. het noemen van deze methode zal een UnsupportedOperationException.De bibliotheek is ontworpen voor bestandgebaseerde 3D-verwerking - het laden, manipuleren, transformeren en besparen van modellen - in plaats van realtime rendering aan een display.

Open source en licentie

Aspose.3D FOSS voor Java wordt uitgebracht onder de MIT licentie.Dit betekent dat je vrij bent om:

• Gebruik de bibliotheek in commerciële en eigendomsapplicaties.
• Verander de broncode om aan uw behoeften te passen.
• Verdeling van de bibliotheek als onderdeel van uw eigen software.

Er zijn geen royalty-kosten, geen gebruiksbeperkingen en geen toewijzingseisen die verder gaan dan wat in de MIT-licentie wordt aangegeven.

De volledige broncode is gehuurd op GitHub, en bijdragen zijn welkom: HTTPS://github.com/aspose-3d-foss/Aspose.3D-FOSS-voor Java

Systemvereisten

te beginnen

Hier zijn de middelen om u te helpen op en lopen:

• Documentatie - uitgebreide gids en API-wandelroutes zijn beschikbaar op de Aspose.3D documentatie site.
• Kennisbasis - praktische hoe-to artikelen en problemen oplossen tips in de 3D KB.
• Vuur Referentie - gedetailleerde klasse en methode verwijzing naar de Aspose.3D API Referentie.
• Kode bron - browsen en bijdragen aan de GitHub.
• Maven Centraal - het pakket wordt gepubliceerd als org.aspose:aspose-3d-foss:26.5.0 Op het Maven Central.

Algemene gebruik van cases

Hier zijn enkele praktische scenario’s waar Aspose.3D FOSS voor Java goed past:

Format Conversie Pipelines

Veel teams ontvangen 3D-activa in één format, maar hebben ze nodig in een andere. Een ontwerpersteam kan werken in FBX terwijl het webteam glTF heeft. De bibliotheek laat u automatische conversiepijpen bouwen:

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

Voordat u een 3D-actief in uw applicatie integrert, wilt u mogelijk de inhoud ervan valideren - door node tellen te controleren, geometrie te verificeren of bevestigen dat verwachte elementen aanwezig zijn:

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

Scène vergadering

U kunt meerdere modellen opladen en ze combineren in een enkele scène:

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

Wat is de volgende

In de komende posts zullen we omvatten:

• Een diepe duik in de belangrijkste kenmerken van het scène-graph API, materialen en wiskundige utiliteiten.
• Een praktische gids om te werken met elk ondersteund 3D-formaat - OBJ, STL, glTF en FBX - inclusief laden/slaan opties en batch conversie patterns.

Wees verbaasd en voel je vrij om de bibliotheek te verkennen en uw feedback op GitHub te delen.