Belangrijkste kenmerken van Aspose.3D FOSS voor Java

In de introductiebericht, we bespraken wat Aspose.3D FOSS voor Java is en hoe je kunt beginnen. Dit bericht gaat dieper in op de belangrijkste functies die de bibliotheek vormen, met codevoorbeelden voor elk gebied.

Alle voorbeelden gaan uit van de volgende import:

import com.aspose.threed.*;

En de Maven-dependency:

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

Scene Graph API

De scenegraph is de basis van Aspose.3D FOSS voor Java. Elk 3D-model – of het nu uit een bestand is geladen of programmatisch is opgebouwd – wordt weergegeven als een boom van knooppunten met als wortel een Scene object.

Scene

De Scene klasse is het toegangspunt voor alle bewerkingen. Je kunt een lege scène maken of er een laden vanuit een bestand:

// Empty scene
Scene scene = new Scene();

// Load from file
Scene loaded = Scene.fromFile("model.obj");

// Load with explicit options
Scene fromStl = Scene.fromFile("part.stl", new StlLoadOptions());

De wortel van de knooppuntboom is toegankelijk via getRootNode().

Node

Een Node vertegenwoordigt een benoemde positie in de sceneboom. Knooppunten kunnen kinderen hebben, waardoor een hiërarchie ontstaat. Elk knooppunt draagt een lokale Transform en een berekende GlobalTransform.

Scene scene = new Scene();

// Create a child node under the root
Node box = scene.getRootNode().createChildNode("Box");

// Create a nested hierarchy
Node arm = scene.getRootNode().createChildNode("Arm");
Node hand = arm.createChildNode("Hand");
Node finger = hand.createChildNode("Finger");

Je kunt ook nodes onafhankelijk construeren en later koppelen:

Node standalone = new Node("Standalone");
scene.getRootNode().getChildNodes().add(standalone);

Entity en Mesh

Een Entity is een abstracte basisklasse voor alles wat aan een knooppunt kan worden gekoppeld – geometrie, camera’s en lichten. Het meest voorkomende entiteitstype is Mesh, die polygonale geometrie bevat (vertices, faces, en normals).

Scene scene = Scene.fromFile("cube.obj");

// Traverse nodes and inspect entities
for (Node child : scene.getRootNode().getChildNodes()) {
    Entity entity = child.getEntity();
    if (entity instanceof Mesh) {
        Mesh mesh = (Mesh) entity;
        System.out.println("Node: " + child.getName());
        System.out.println("  Vertices: " + mesh.getControlPoints().size());
    }
}

Camera

Camera’s zijn entiteiten die aan nodes worden gekoppeld:

Scene scene = new Scene();

Node cameraNode = scene.getRootNode().createChildNode("MainCamera");
// Camera entity can be assigned to the node

Opmerking: De Camera klasse in de Java editie is een minimale stub met alleen constructors. Camera‑entiteiten die aan knooppunten zijn gekoppeld, zijn niet geschreven bij het exporteren naar glTF of een ander formaat — de glTF-exporteur verwerkt alleen Mesh entiteiten. Vertrouw er niet op dat cameragegevens behouden blijven in geëxporteerde bestanden.

Opmerking: De Light klasse is niet beschikbaar in de Java editie. Scèneverlichtingsgegevens van geïmporteerde bestanden worden opgeslagen als generieke Entity objecten.

Formaat-onafhankelijke laden en opslaan

Een van de sterke punten van de bibliotheek is dat de scènegrafiek formaatonafhankelijk is. Je laadt vanuit elk ondersteund formaat, bewerkt de scène via een enkele API, en slaat op naar elk ondersteund formaat.

// Load OBJ, save as glTF
Scene scene = Scene.fromFile("input.obj");
scene.save("output.gltf");

// Load FBX, save as STL (FBX is import only)
Scene scene2 = Scene.fromFile("character.fbx");
scene2.save("character.stl");

// Load STL, save as GLB
Scene scene3 = Scene.fromFile("part.stl", new StlLoadOptions());
GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);
scene3.save("part.glb", opts);

Het formaat wordt bepaald door de bestandsextensie. Je kunt ook expliciete opslaanopties doorgeven om de output te controleren:

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

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

Materialen

Aspose.3D FOSS for Java biedt een PBR (Physically Based Rendering) materiaalmodel via PbrMaterial. Dit is de enige concrete materiaalklasse in de Java editie.

PbrMaterial

Een fysiek gebaseerd renderingsmateriaal dat albedo-, metaal- en ruwheidsparameters gebruikt. Dit is het standaard materiaalmodel voor glTF en moderne realtime‑engines.

PbrMaterial pbr = new PbrMaterial();
pbr.setAlbedo(new Vector4(0.8, 0.2, 0.2, 1.0)); // Red-ish base color
pbr.setMetallicFactor(0.0);  // Non-metallic
pbr.setRoughnessFactor(0.5); // Medium roughness

Het behouden van materialen over verschillende formaten hangt af van de mogelijkheden van het doel­formaat. PBR-materialen worden natuurlijk gemapt naar glTF- en GLB-output.

Transform en Spatial

Elke Node in de scènegrafiek heeft een Transform die zijn positie, rotatie en schaal definieert ten opzichte van zijn ouder.

Lokale Transform

Scene scene = new Scene();
Node node = scene.getRootNode().createChildNode("TestNode");

Transform t = node.getTransform();
t.setTranslation(1, 2, 3);       // Position
t.setScale(2, 2, 2);             // Uniform scale
t.setEulerAngles(0, 45, 0);      // Euler rotation in degrees

Globale Transform

De GlobalTransform is de berekende wereld-ruimtetransformatie, waarbij de volledige ouderketen in aanmerking wordt genomen. Dit is alleen-lezen en wordt automatisch bijgewerkt.

Node parent = scene.getRootNode().createChildNode("Parent");
parent.getTransform().setTranslation(10, 0, 0);

Node child = parent.createChildNode("Child");
child.getTransform().setTranslation(5, 0, 0);

// Child's global position is (15, 0, 0)
GlobalTransform global = child.getGlobalTransform();

Deze ouder‑kind transform‑erfenis volgt het standaard scène‑grafiekpatroon dat wordt gebruikt door 3D‑engines en DCC‑tools.

Wiskundige hulpprogramma’s

De bibliotheek bevat kernwiskundige types voor 3D‑bewerkingen.

Vector3

Een vector met drie componenten die wordt gebruikt voor posities, richtingen, normaalvectoren en kleuren.

Vector3 a = new Vector3(1, 0, 0);
Vector3 b = new Vector3(0, 1, 0);

// Addition
Vector3 sum = Vector3.add(a, b); // (1, 1, 0)

Matrix4

Een 4x4‑transformatiematrix voor het combineren van translatie, rotatie en schaal in één bewerking.

Matrix4 mat = new Matrix4();
// Matrix4 is used internally by transforms
// and can be retrieved from GlobalTransform

Quaternion

Een rotatie‑representatie die gimbal lock voorkomt en soepel interpoleert. Quaternions worden intern gebruikt door het transformatiesysteem.

BoundingBox

Een as‑gealigneerde begrenzingsbox voor ruimtelijke queries, botsingscontroles en scène‑analyse.

BoundingBox bbox = new BoundingBox();
// BoundingBox can be constructed directly with min/max Vector3 values

Opmerking: Node.getBoundingBox() en Entity.getBoundingBox() zijn nog niet geïmplementeerd. Beide geven een lege BoundingBox (met sentinel Double.MAX_VALUE / Double.MIN_VALUE waarden) ongeacht de mesh-geometry. Gebruik deze methoden niet om daadwerkelijke geometriegrenzen te berekenen in deze versie.

Bekende beperkingen

Het is vermeldenswaard dat Scene.render() is niet ondersteund in de FOSS-editie. Het aanroepen zal een UnsupportedOperationException. De bibliotheek is ontworpen voor bestandsgebaseerde 3D-verwerking – laden, transformeren en opslaan – in plaats van realtime rendering.

Samenvatting

De belangrijkste kenmerken van Aspose.3D FOSS voor Java worden onderverdeeld in vijf gebieden:

In de volgende post lopen we praktische stap‑voor‑stap‑handleidingen door per formaat, met OBJ, STL, glTF en FBX, inclusief gedetailleerde laad‑ en opslagopties.