Einführung Aspose.3D FOSS für Java

Wir freuen uns, die Verfügbarkeit von Aspose.3D FOSS für Java - eine kostenlose, offenes Quellbibliothek für die Arbeit mit 3D-Fileformaten in Java-Anwendungen. als reine Java Lösung ohne heimische Abhängigkeiten gebaut, läuft die Bibliotheke auf Java 21 und später, so dass es zu einer breiten Palette von Projekten und Umgebungen zugänglich ist.

Dieser Beitrag geht durch, was die Bibliothek bietet, wie man anfängt und wo man hier gehen kann.

Was ist Aspose.3D FOSS für Java?

Aspose.3D FOSS für Java ist eine leichte 3D-Dateiverarbeitung Bibliothek veröffentlicht unter der Mit Lizenz. Es bietet eine Scene-Graph API, die es Ihnen ermöglicht, 3D Modelle über mehrere weit verbreitete Formate zu laden, zu inspizieren, umzubauen und speichern. Die Bibliothek ist vollständig in Java geschrieben und erfordert keine externen native Binaren oder Plattformspezifische Konfigurationen.

Der Quellcode ist auf GitHub verfügbar: HTTPS://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Schlüsselhighlights

• reine Java - keine JNI, keine native Bibliotheken, kein Plattformsbeschränkungen.
• Java 21+ Kompatibel ist.
• MIT lizenziert - sie in persönlichen, kommerziellen oder Eigentumsprojekten ohne Einschränkungen verwenden.
• Scene-Grafe Architektur - ein bekanntes Baum von Knoten, Messen, Kameras und Materialien.
• Multi-Format Unterstützung - Lesen und schreiben Sie OBJ, STL, glTF 2.0 und GLB Dateien; lesen Sie FBX-Dateien.

Schnelle Start

Maven Installation

Fügen Sie die folgenden Abhängigkeit an Ihre pom.xml:

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

Ihre erste Konvertierung

Der einfachste Gebrauch ist es, eine 3D-Datei in einem Format zu laden und sie in einen anderen zu speichern. Hier ist eine zweisetzige Konvertierung von OBJ nach 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");
    }
}

Die Scene Die Klasse ist der zentrale Eingangspunkt. Call Scene.fromFile() mit einer Datei-Path, um ein Modell zu laden, dann rufen Sie save() mit der Zielstraße. Die Bibliothek infiziert das Format aus der Dateierweiterung.

Eine Bühne von Scratch bauen

Sie können auch Szenen programmatisch erstellen:

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

Dies schafft eine neue Szenen, fügt einen Kindernode namens “Box” unter dem Wurzel hinzu, positioniert es in Koordinaten (1, 2, 3), und exportiert das Ergebnis als glTF-Datei.

Laden mit Format-spezifischen Optionen

Wenn Sie eine bessere Kontrolle über den Ladenprozess benötigen, bietet jedes Format eine dedizierte Optionsklasse. Zum Beispiel laden Sie ein STL-Datei mit ausdrücklichen Optionen:

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

Die Scene.fromFile() Die statische Methode akzeptiert jede der Lastoptionen: ObjLoadOptions, StlLoadOptions, GltfLoadOptions,oder FbxLoadOptions.

Über die Scene Graph

Sobald eine Szene geladen ist, können Sie den Knotenbaum durchlaufen, um seine Inhalte zu überprüfen oder zu modifizieren:

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

Dieses Muster ist nützlich für Debugging, Berichte über Modellgehalte zu generieren oder selektiv Teile einer Szene vor der erneuten Exportung zu modifizieren.

Transformationen anwenden

Positionierung von Noten im 3D-Raum erfolgt durch die Transform Objekt auf jeder 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");
    }
}

Transformationen folgen dem Standard-Moder-Kind-Erbe: Die Weltraumposition eines Kindes ist die Kombination seiner lokalen Transformation und alle Vorfahren transformieren bis zur Wurzel.

Was ist enthalten

Die Bibliothek schiffe mit einem fokussierten Set von Fähigkeiten, die um das 3D-Szenegrafmodell entworfen sind.

Scene Grafiken

Das Scene-Grafik ist der Rückenpunkt der API. Jeder 3D-Datei wird als Baumstruktur dargestellt:

Materialien

Die Bibliothek bietet ein Materialmodell PBR (Physically Based Rendering):

• PbrMaterial - physisch basierend rendering material mit albedo, metallness, grusamkeit, emissive farbe und transparenz. dies ist die einzige konkrete materielle klasse verfügbar in der Java-Edition.

Mathematikn nutzungen

Die com.aspose.threed Das Paket enthält die wesentlichen Mathematik-Primitiven:

• Vektor 3 - 3-Komponenten-Vektor für Positionen, Richtungen und Farben.
• Matrix 4 - 4x4 Transformationsmatrix.
• Quaternion Rotation der Repräsentation.
• BoundingBox - Axis-aligned Bounding Box für Raumfragen.

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

Laden und speichern Optionen

Jedes Format verfügt über spezielle Optionsklassen, die Ihnen ermöglichen, das Einfuhr- und Exportverhalten zu kontrollieren:

Zum Beispiel, um glTF mit gut gedruckten JSON und einem fließenden Koordinatsystem auszuüben:

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

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

Unterstützte Formate

Die folgende Tabelle erfasst die Formate, die Aspose.3D FOSS für Java lesen und schreiben kann.

OBJ, STL, glTF und GLB unterstützen sowohl Ladung als auch Spar. FBX wird nur für den Import unterstützt.

Format Auswahl Guide

Die Wahl des richtigen Formats hängt von Ihrem Verwendungszustand ab:

• OBJ Ideal, wenn Sie maximale Kompatibilität über 3D-Tools benötigen. fast jede Modellierung Anwendung kann OBJ lesen und schreiben. Es funktioniert gut für den Datenaustausch von Mesh aber trägt nur grundlegende Materialinformationen durch die Mitbeamten MTL Dateien.
• STL ist das Format der Wahl für 3D-Druck-Workflüsse. Es speichert Rohgeometrie ohne Materialien oder Szenahergier, die genau das ist, was Schleimer Software erwartet. Wenn Ihre Pipeline auf einem 3d-Printer endet, ist STL die einfache Wahl.
• Gltf ist der moderne Standard für Web und Real-Time 3D. Es unterstützt PBR Materialien, vollständige Szenenhierarchien und ist für effiziente Übertragung konzipiert. Verwenden Sie glTF beim Bau von webbasierten Zuschauern, arbeiten mit three.js oder Babylon.JS, oder zielen Sie auf jede real-time rendering Pipeline.
• FBX ist tief in die Spielentwicklung und digitale Inhalte-Workflows integriert. Es unterstützt reiche Scene-Daten einschließlich Hierarchien und Materialien. Aspose.3D FOSS für Java unterstütze FBX Einwanderung nur - verwenden Sie es, um FBX-Vermögenswerte zu laden und sie in andere Formate zu konvertieren.

Bekannte Einschränkungen

Es ist wichtig zu beachten, dass Scene.render() ist nicht unterstützt in der FOSS-Edition. die Anrufe dieser Methode wird eine UnsupportedOperationException.Die Bibliothek ist für die 3D-Verarbeitung auf Datei - Laden, Manipulieren, Transformieren und Speichern Modelle - anstatt in Echtzeit zu einem Display renderieren.

Open Source und Lizenzierung

Aspose.3D FOSS für Java wird unter der MIT Lizenz.Das bedeutet, dass Sie frei sind:

• Verwenden Sie die Bibliothek in kommerziellen und proprietären Anwendungen.
• Ändern Sie den Quellcode, um Ihren Bedürfnissen zu entsprechen.
• Verteilen Sie die Bibliothek als Teil Ihrer eigenen Software.

Es gibt keine royalty-gebühren, keine Nutzungsbeschränkungen und keine zugehörigen Anforderungen außerhalb der MIT-Lizenz.

Der vollständige Quellcode wird auf GitHub gehalten und Beiträge sind willkommen: HTTPS://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Systemanforderungen

zu beginnen

Hier sind die Ressourcen, um Ihnen zu helfen, aufzustehen und laufen:

• Dokumentation - umfassende Leitfaden und API-Wanderwege sind auf der Aspose.3D Dokumentation Website.
• Wissensbasis - praktische wie-to Artikel und Problemlösung Tipps in der Abkürzung 3D KB.
• Feuerreferenz - detaillierte Klasse und Methode beziehen sich auf die Aspose.3D API Referenz.
• Quellcode - Browse und beitragen zu GitHub.
• Maven Zentral - das Paket wird als org.aspose:aspose-3d-foss:26.5.0 auf dem Maven Central.

Häufige Verwendungszahlen

Hier sind einige praktische Szenarien, in denen Aspose.3D FOSS für Java gut passt:

Formatierung von Konvertierungspipeln

Viele Teams erhalten 3D-Vermögenswerte in einem Format, aber brauchen sie in einer anderen. Ein Designteam kann in FBX arbeiten, während das Webteam glTF benötigt. Die Bibliothek ermöglicht es Ihnen, automatisierte Konvertierungspipel zu bauen:

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

Bevor Sie ein 3D-Vermögenswert in Ihre Anwendung integrieren, möchten Sie möglicherweise seine Inhalte validieren - die Notenzahlen überprüfen, die Geometrie übermitteln oder bestätigen, dass erwartete Elemente vorhanden sind:

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

Bühne Versammlung

Sie können mehrere Modelle laden und sie in eine einzige Szenen kombinieren:

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

Was ist Nächster

In den kommenden Posts werden wir umfasst:

• Ein tiefes Tauchen in die Schlüsselfunktionen der Scene-Graph API, Materialien und Mathe-Nutbücher.
• Ein praktischer Leitfaden, um mit jedem unterstützten 3D-Format - OBJ, STL, glTF und FBX - zu arbeiten, einschließlich Ladungs- / Speicheroptionen und Batchkonvertierungspatroon.

Bleiben Sie aufgeregt und fühlen Sie sich frei, die Bibliothek zu erkunden und Ihre Feedback auf GitHub zu teilen.