Wprowadzamy Aspose.3D FOSS dla Java

Z radością ogłaszamy dostępność Aspose.3D FOSS for Java – darmowa, otwarto‑źródłowa biblioteka do pracy z formatami plików 3D w aplikacjach Java. Zbudowana jako czyste rozwiązanie Java bez natywnych zależności, biblioteka działa na Java 21 i nowszych, co czyni ją dostępną dla szerokiego zakresu projektów i środowisk.

Ten post przechodzi przez to, co biblioteka oferuje, jak rozpocząć oraz dokąd dalej iść.

Czym jest Aspose.3D FOSS dla Java?

Aspose.3D FOSS for Java jest lekką biblioteką przetwarzania plików 3D opublikowaną pod licencją MIT. Udostępnia API grafu scen, które pozwala ładować, przeglądać, przekształcać i zapisywać modele 3D w różnych powszechnie używanych formatach. Biblioteka jest w całości napisana w Java i nie wymaga zewnętrznych natywnych binarek ani specyficznych konfiguracji platformowych.

Kod źródłowy jest dostępny na GitHubie: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Kluczowe wyróżnienia

• Czysty Java – brak JNI, brak natywnych bibliotek, brak ograniczeń platformowych.
• Java 21+ kompatybilny.
• na licencji MIT – używaj go w projektach osobistych, komercyjnych lub własnościowych bez ograniczeń.
• Architektura grafu sceny – znane drzewo węzłów, siatek, kamer i materiałów.
• Obsługa wielu formatów – odczyt i zapis plików OBJ, STL, glTF 2.0 i GLB; odczyt plików FBX.

Szybki start

Instalacja Maven

Dodaj następującą zależność do swojego pom.xml:

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

Twoja pierwsza konwersja

Najprostszy przypadek użycia to wczytanie pliku 3D w jednym formacie i zapisanie go w innym. Oto dwuliniowa konwersja z OBJ do 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");
    }
}

Ten Scene klasa jest centralnym punktem wejścia. Wywołaj Scene.fromFile() z ścieżką do pliku, aby załadować model, a następnie wywołaj save() z docelową ścieżką. Biblioteka wywnioskuje format na podstawie rozszerzenia pliku.

Tworzenie sceny od podstaw

Możesz także tworzyć sceny programowo:

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

Tworzy to nową scenę, dodaje węzeł potomny o nazwie “Box” pod korzeniem, ustawia go w współrzędnych (1, 2, 3) i eksportuje wynik jako plik glTF.

Ładowanie z opcjami specyficznymi dla formatu

Gdy potrzebujesz dokładniejszej kontroli nad procesem ładowania, każdy format udostępnia dedykowaną klasę opcji. Na przykład, ładowanie pliku STL z wyraźnie określonymi opcjami:

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

Ten Scene.fromFile() metoda statyczna przyjmuje dowolny z typów opcji ładowania: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, lub FbxLoadOptions.

Przeglądanie grafu sceny

Po załadowaniu sceny możesz przejść po drzewie węzłów, aby sprawdzić lub zmodyfikować jego zawartość:

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

Ten wzorzec jest przydatny do debugowania, generowania raportów o zawartości modelu lub selektywnej modyfikacji części sceny przed ponownym eksportem.

Stosowanie transformacji

Pozycjonowanie węzłów w przestrzeni 3D odbywa się za pomocą Transform obiektu na każdym 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");
    }
}

Transformacje podążają za standardowym modelem dziedziczenia rodzic‑dziecko: pozycja dziecka w przestrzeni światowej jest kombinacją jego lokalnej transformacji oraz wszystkich transformacji przodków aż do korzenia.

Co jest w zestawie

Biblioteka dostarcza skoncentrowany zestaw funkcji zaprojektowany wokół modelu grafu sceny 3D.

Graf sceny

Graf sceny jest podstawą API. Każdy plik 3D jest reprezentowany jako struktura drzewa:

Materiały

Biblioteka udostępnia model materiału PBR (Physically Based Rendering):

• PbrMaterial – materiał renderingu oparty na fizyce z albedo, metalness, roughness, emissive color i transparency. To jedyna konkretna klasa materiału dostępna w edycji Java.

Narzędzia matematyczne

Ten com.aspose.threed pakiet zawiera podstawowe prymitywy matematyczne:

• Vector3 – wektor 3-składnikowy dla pozycji, kierunków i kolorów.
• Matrix4 – macierz przekształcenia 4x4.
• Quaternion – reprezentacja obrotu.
• BoundingBox – pudełko ograniczające wyrównane do osi dla zapytań przestrzennych.

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

Opcje ładowania i zapisu

Każdy format ma dedykowane klasy opcji, które pozwalają kontrolować zachowanie importu i eksportu:

Na przykład, aby wyeksportować glTF z ładnie sformatowanym JSON i odwróconym układem współrzędnych:

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

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

Obsługiwane formaty

Poniższa tabela podsumowuje formaty, które Aspose.3D FOSS dla Java może odczytywać i zapisywać.

OBJ, STL, glTF i GLB obsługują zarówno wczytywanie, jak i zapisywanie. FBX jest obsługiwany tylko do importu.

Przewodnik wyboru formatu

Wybór odpowiedniego formatu zależy od Twojego przypadku użycia:

• OBJ jest idealny, gdy potrzebujesz maksymalnej kompatybilności między narzędziami 3D. Prawie każde oprogramowanie do modelowania potrafi odczytywać i zapisywać pliki OBJ. Dobrze sprawdza się przy wymianie danych siatek, ale przenosi jedynie podstawowe informacje o materiałach za pośrednictwem towarzyszących plików MTL.
• STL jest formatem wyboru dla przepływów pracy druku 3D. Przechowuje surową triangulowaną geometrię bez materiałów ani hierarchii sceny, co dokładnie odpowiada temu, czego oczekuje oprogramowanie slicer. Jeśli Twój pipeline kończy się na drukarce 3D, STL jest prostym wyborem.
• glTF jest nowoczesnym standardem dla sieci i grafiki 3D w czasie rzeczywistym. Obsługuje materiały PBR, pełne hierarchie sceny i jest zaprojektowany do efektywnego przesyłania. Używaj glTF przy tworzeniu przeglądarek internetowych, pracy z three.js lub Babylon.js, lub celując w dowolny pipeline renderingu w czasie rzeczywistym.
• FBX jest głęboko zintegrowany z procesami tworzenia gier i cyfrowej produkcji treści. Obsługuje bogate dane scen, w tym hierarchie i materiały. Aspose. 3D FOSS for Java obsługuje FBX tylko import – użyj go do wczytywania zasobów FBX i konwertowania ich na inne formaty.

Znane ograniczenia

Ważne jest, aby zauważyć, że Scene.render() jest nie jest obsługiwane w edycji FOSS. Wywołanie tej metody spowoduje wyrzucenie an UnsupportedOperationException. Biblioteka jest przeznaczona do przetwarzania 3D opartego na plikach — wczytywania, manipulacji, transformacji i zapisywania modeli — zamiast renderowania w czasie rzeczywistym na wyświetlaczu.

Open Source i licencjonowanie

Aspose.3D FOSS dla Java jest wydany na Licencja MIT. Oznacza to, że możesz:

• Używać biblioteki w aplikacjach komercyjnych i własnościowych.
• Modyfikować kod źródłowy, aby dopasować go do swoich potrzeb.
• Dystrybuuj bibliotekę jako część własnego oprogramowania.

Nie ma opłat licencyjnych, limitów użytkowania ani wymagań dotyczących przypisania poza tym, co określa licencja MIT.

Pełny kod źródłowy jest hostowany na GitHubie, a wkłady są mile widziane: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Wymagania systemowe

Rozpoczęcie

Oto zasoby, które pomogą Ci rozpocząć pracę:

• Dokumentacja – kompleksowe przewodniki i instrukcje API są dostępne na Aspose.3D strona dokumentacji.
• Baza wiedzy – praktyczne artykuły instruktażowe i porady rozwiązywania problemów w Aspose.3D KB.
• Referencja API – szczegółowa referencja klas i metod na Referencja API Aspose.3D.
• Kod źródłowy – przeglądaj i przyczyniaj się na GitHub.
• Maven Central – pakiet jest publikowany jako com.aspose:aspose-3d-foss w Maven Central.

Typowe przypadki użycia

Oto kilka praktycznych scenariuszy, w których Aspose.3D FOSS dla Java sprawdza się doskonale:

Potoki konwersji formatów

Wiele zespołów otrzymuje zasoby 3D w jednym formacie, ale potrzebuje ich w innym. Zespół projektowy może pracować w formacie FBX, podczas gdy zespół webowy potrzebuje glTF. Biblioteka umożliwia tworzenie zautomatyzowanych potoków konwersji:

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

Zanim zintegrować zasób 3D z aplikacją, możesz chcieć zweryfikować jego zawartość – sprawdzając liczbę węzłów, weryfikując geometrię lub potwierdzając, że oczekiwane elementy są obecne:

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

Montaż sceny

Możesz wczytać wiele modeli i połączyć je w jedną 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");

Co dalej

W nadchodzących wpisach omówimy:

• Dogłębne omówienie kluczowych funkcji API grafu sceny, materiałów i narzędzi matematycznych.
• Praktyczny przewodnik po pracy z każdym obsługiwanym formatem 3D – OBJ, STL, glTF i FBX – obejmujący opcje wczytywania/zapisywania oraz wzorce konwersji wsadowej.

Bądźcie na bieżąco i zachęcamy do eksploracji biblioteki oraz dzielenia się opinią na GitHubie.