Introducción Aspose.3D FOSS para Java

Estamos encantados de anunciar la disponibilidad de Aspose.3D FOSS para Java - una biblioteca de código abierto para trabajar con formatos de archivos 3D en aplicaciones Java. Construida como una solución pura Java sin dependencias nativas, la biblioteca se ejecuta en Java 21 y más tarde, lo que hace accesible a un amplio abanico de proyectos y entornos.

Este post se dirige a lo que la biblioteca ofrece, cómo comenzar y dónde ir de aquí.

¿Qué es el 3D FOSS para Java?

Aspose.3D FOSS para Java es una biblioteca de procesamiento de archivos 3D ligero publicada bajo el Licencia MIT. proporciona una API de gráficos de escena que le permite cargar, inspeccionar, transformar y salvar modelos 3D a través de varios formatos ampliamente utilizados. la biblioteca está escrita en Java y no requiere ninguna configuración nativa externa o específica de plataforma.

El código de fuente está disponible en GitHub: WEB WEB www.github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Los principales destacamientos

• El java puro - No hay JNI, no bibliotecas nativas, ni restricciones de plataforma.
• El Java 21+ compatible .
• MIT Licenciado - utilizarlos en proyectos personales, comerciales o propiedad sin restricciones.
• Arquitectura Scene-Graph - un árbol familiar de nodos, mesas, cámaras y materiales.
• Apoyo multiformato - leer y escribir los archivos OBJ, STL, glTF 2.0 y GLB; leer los ficheros FBX.

Inicio rápido

Instalación Maven

Añade la siguiente dependencia a tu pom.xml:

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

Su primera conversión

El caso más sencillo de uso es cargar un archivo 3D en un formato y guardarlo en otro. Aquí hay una conversión de dos líneas desde OBJ a 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");
    }
}

El Scene La clase es el punto de entrada central.Call Scene.fromFile() con un camino de archivo para cargar un modelo, luego llamar save() La biblioteca infierte el formato de la extensión del archivo.

Construir una escena de Scratch

También puedes crear escenarios programáticos:

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

Esto crea una nueva escena, añade un nodo infantil llamado “Casa” debajo de la raíz, lo coloca en coordenadas (1, 2, 3), y exporta el resultado como un archivo glTF.

Cargar con opciones específicas de formato

Cuando necesita un control más fin sobre el proceso de carga, cada formato proporciona una clase de opciones dedicada. Por ejemplo, cargar un archivo STL con opciones explícitas:

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

El Scene.fromFile() El método estático acepta cualquiera de los tipos de opciones de carga: ObjLoadOptions, StlLoadOptions, GltfLoadOptions,o FbxLoadOptions.

Viaje por el escenario gráfico

Una vez que una escena se carga, puede caminar por el árbol de nodo para inspeccionar o modificar su contenido:

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

Este patrón es útil para desbloquear, generar informes sobre los contenidos de modelos o modificar selectivamente partes de una escena antes de reexportarse.

Aplicación de Transformes

La posición de los nodos en el espacio 3D se realiza a través del Transform Objetos en cada uno de los 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");
    }
}

Los trasformos siguen el modelo de herencia parental-infantil estándar: la posición espacial del niño es la combinación de su transformación local y todos los ancestros se transforman hasta la raíz.

Lo que está incluido

La biblioteca embarca con un conjunto centrado de capacidades diseñadas alrededor del modelo 3D escenógrafo.

Escena de Graph

El gráfico de escena es el cuadro trasero de la API. Cada archivo 3D se representa como una estructura árbol:

Materiales

La biblioteca proporciona un modelo de material PBR (Rendering Físicamente Basado):

• PbrMaterial - material de rendimiento basado en la física con albedo, metalicidad, rugidez, color emissivo y transparencia. esta es la única clase de material concreto disponible en el Java Edition.

Utilidades Matemáticas

El com.aspose.threed El paquete incluye los primitivos matemáticos esenciales:

• Vector 3 - Vector de 3 componentes para posiciones, direcciones y colores.
• Matrix 4 - 4x4 matrícula de transformación.
• Quaternidad La representación de la rotación.
• BoundingBox - La caja de límite alineada a la esfera para las consultas espaciales.

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

Cargar y ahorrar opciones

Cada formato tiene clases de opciones dedicadas que le permiten controlar el comportamiento de importación y exportación:

Por ejemplo, para exportar glTF con JSON bien impreso y un sistema de coordenadas flipped:

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

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

Formatos apoyados

La siguiente tabla resume los formatos que Aspose.3D FOSS para Java puede leer y escribir.

OBJ, STL, glTF y GLB soportan tanto cargamiento como ahorro. FBX se apoya para la importación solo.

Guía de Selección Formato

La elección del formato adecuado depende de su caso de uso:

• OBJ Es ideal cuando necesita la máxima compatibilidad a través de las herramientas 3D. Casi toda aplicación de modelado puede leer y escribir OBJ. Funciona bien para el intercambio de datos de mesh pero lleva sólo información material básica a partir de los archivos MTL compañeros.
• STL Es el formato de elección para los flujos de trabajo de impresión 3D. Almacenan geometría triangular cruda sin materiales o hierarquía de escenarios, lo que es exactamente lo cual espera el software de la capa. Si su pipeline termina en una impresora 3d, STL es la opción sencilla.
• GTTF Es el estándar moderno para la web y 3D en tiempo real. apoya materiales PBR, hierarquías de escenario completo, y se diseñó para una transmisión eficiente. Utilice glTF cuando construye espectadores basados en la Web, trabajando con three.js o Babylon.js, o dirigir cualquier pipeline de rendimiento en tiempos real .
• FBX está profundamente integrado en el desarrollo de juegos y flujos de trabajo de creación de contenido digital. apoya datos ricos de escenario incluyendo hierarquías y materiales. Aspose.3D FOSS para Java soporta FBX Sólo importación - Utilice para cargar activos FBX y convertirlos en otros formatos.

Conocidas limitaciones

Es importante señalar que Scene.render() Es el No apoyado en la edición FOSS. llamando este método se lanzará un UnsupportedOperationException.La biblioteca está diseñada para el procesamiento 3D basado en archivos - cargar, manipular, transformar y ahorrar modelos - en lugar de renderizar a un display en tiempo real.

Open Source y Licenciación

Aspose.3D FOSS para Java se libera bajo el Licencia MIT.Esto significa que usted es libre de:

• Utilice la biblioteca en aplicaciones comerciales y propiedad.
• Modificar el código de fuente para adaptarse a sus necesidades.
• Distribuye la biblioteca como parte de su propio software.

No hay tarifas de royalty, no hay límites de uso y no existen requisitos de atribución más allá de lo que especifica la licencia MIT.

El código fuente completo se alojará en GitHub, y las contribuciones son bienvenidas: WEB WEB www.github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Requisitos del sistema

Empezando a

Aquí están los recursos para ayudarle a levantarse y correr:

• Documentación - Guías completos y pasillos API están disponibles en el Sitio web de documentación 3D.
• Base de conocimientos - Cómo hacer artículos y consejos de resolución de problemas en el Cálculo 3D KB.
• El referente de API - referencia de clase y método detallada en el Aspose.3D API de referencia.
• Código de fuente - browsing y contribuir a GitHub.
• Maven Central - El paquete se publica como org.aspose:aspose-3d-foss:26.5.0 en el centro de Maven.

Casos de uso común

Aquí hay algunos escenarios prácticos donde Aspose.3D FOSS para Java se ajusta bien:

Formato de conversión de tubos

Muchas equipos reciben activos 3D en un formato pero necesitan de ellos en otro.Un equipo de diseño puede trabajar en FBX mientras que el equipo web necesita glTF. La biblioteca le permite construir tuberías de conversión automatizadas:

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

Antes de integrar un activo 3D en su aplicación, puede que desee validarse su contenido - comprobar los cuentos de nódulos, verificar la geometría o confirmar que los elementos esperados están presentes:

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

Asamblea de escenarios

Puedes cargar varios modelos y combinarlos en una sola escena:

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

¿Qué es el siguiente

En los próximos posts, vamos a cubrir:

• Un profundo mergullo en las características clave de la API de escenario-grafía, materiales y utilidades matemáticas.
• Un guía práctico para trabajar con cada formato 3D apoyado - OBJ, STL, glTF y FBX - incluyendo las opciones de carga/salvación y los patrones de conversión de batch.

Mantenga tonto, y siente libre para explorar la biblioteca y compartir su feedback en GitHub.