Trabajando con formatos de archivo 3D en Java usando Aspose.3D FOSS

Aspose.3D FOSS para Java admite cinco formatos de archivo 3D: OBJ, STL, glTF, GLB, y FBX (solo importación).

Todos los ejemplos usan el com.aspose.threed.* paquete:

import com.aspose.threed.*;

Dependencia Maven:

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

Panorama de formatos

Antes de profundizar, aquí hay una visión rápida de los cuatro formatos compatibles y sus casos de uso típicos.

OBJ, STL, glTF y GLB admiten tanto importación como exportación. FBX es compatible para solo importación. GLB (binary glTF) se produce mediante GltfSaveOptions con setContentType(FileContentType.BINARY).

OBJ: Wavefront Object

OBJ es uno de los formatos de malla 3D más ampliamente soportados. Almacena la geometría como texto plano, con un .mtl archivo complementario para materiales.

Cargando archivos OBJ

El enfoque más sencillo es pasar la ruta del archivo directamente:

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

Para mayor control, use ObjLoadOptions:

ObjLoadOptions opts = new ObjLoadOptions();
Scene scene = Scene.fromFile("model.obj", opts);

Cuando el archivo OBJ hace referencia a un archivo MTL (a través de un mtllib directiva), la biblioteca intentará cargar automáticamente las definiciones de material desde él. El archivo MTL debe estar en el mismo directorio que el archivo OBJ o en la ruta especificada en la directiva.

Guardando como OBJ

Scene scene = Scene.fromFile("input.fbx");
scene.save("output.obj");

Casos de uso de OBJ

• Intercambio de datos de malla entre diferentes herramientas 3D.
• Importando modelos de bibliotecas de recursos que distribuyen en formato OBJ.
• Inspección rápida de la geometría sin jerarquías de escena complejas.

STL: Estereolitografía

STL es el formato estándar para la impresión 3D. Representa geometría triangulada cruda sin materiales, colores ni jerarquía de escena. Los archivos STL vienen en dos variantes: ASCII (legible por humanos) y binario (compacto).

Cargando archivos STL

// Simple load
Scene scene = Scene.fromFile("part.stl");

// With explicit options
StlLoadOptions opts = new StlLoadOptions();
Scene scene = Scene.fromFile("part.stl", opts);

Guardando como STL

Scene scene = Scene.fromFile("model.obj");
scene.save("output.stl");

Para controlar la salida, use StlSaveOptions:

StlSaveOptions opts = new StlSaveOptions();
scene.save("output.stl", opts);

Consideraciones sobre STL

• STL almacena solo geometría de triángulos. Los materiales, texturas y la jerarquía de escena no son compatibles y se descartan al exportar.
• La exportación STL no triangular automáticamente. El STL binario escribe solo los primeros 3 vértices de cada cara del polígono; las caras cuádruples y n‑gonos se truncan silenciosamente. El STL ASCII escribe todos los índices de vértice por cara, produciendo una salida malformada para caras que no son triángulos. Siempre use mallas pre-trianguladas (caras todas triangulares) al exportar a STL.
• El STL binario es significativamente más pequeño que el STL ASCII para modelos grandes.
• STL es el formato preferido cuando el objetivo es una impresora 3D o un software de laminado.

glTF: Formato de Transmisión GL

glTF es un formato moderno diseñado para la transmisión y carga eficiente de contenido 3D, particularmente en la web y en aplicaciones en tiempo real. Soporta materiales PBR, jerarquías de escena y animaciones.

Cargando archivos glTF

Scene scene = Scene.fromFile("scene.gltf");

// With options
GltfLoadOptions opts = new GltfLoadOptions();
Scene scene = Scene.fromFile("scene.gltf", opts);

Guardando como glTF

El guardado básico utiliza la extensión del archivo para determinar el formato:

scene.save("output.gltf");

Para un control detallado, utilice GltfSaveOptions:

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

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

Detalles de GltfSaveOptions

Casos de uso de glTF

• Visores 3D basados en web (three.js, Babylon.js).
• Aplicaciones en tiempo real y motores de juego.
• Preservar definiciones de materiales PBR entre herramientas.

FBX: Filmbox (Solo importación)

FBX es un formato propietario de Autodesk que se usa ampliamente en el desarrollo de juegos y la creación de contenido digital. Aspose.3D FOSS para Java admite FBX para solo importación — la exportación a FBX no está disponible.

Solo FBX binario. El importador de FBX solo lee archivos FBX binarios. Pasar un archivo FBX ASCII lanza ImportException("ASCII FBX format not yet supported - only binary FBX is supported"). La jerarquía de nodos y la extracción de materiales de FBX no están completamente verificadas; escenas FBX complejas pueden no cargarse completamente. Las animaciones y el rigging no están implementados.

Cargando archivos FBX

Scene scene = Scene.fromFile("character.fbx");

// With options
FbxLoadOptions opts = new FbxLoadOptions();
Scene scene = Scene.fromFile("character.fbx", opts);

Convirtiendo FBX a otros formatos

Dado que la exportación de FBX no está soportada, convierta las escenas FBX importadas a glTF, GLB, OBJ o STL:

Scene scene = Scene.fromFile("character.fbx");

// Save as GLB
GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);
scene.save("character.glb", opts);

Casos de uso de FBX

• Importación de activos de malla estática desde herramientas de Autodesk (Maya, 3ds Max) y conversión a otros formatos.
• Cargando geometría FBX binaria y reexportando a glTF/GLB, OBJ o STL.

Conversión por lotes

Un flujo de trabajo común es convertir un directorio completo de archivos de un formato a otro. Aquí hay un patrón para la conversión por lotes:

import com.aspose.threed.*;
import java.io.File;

public class BatchConvert {
    public static void main(String[] args) throws Exception {
        File inputDir = new File("models/obj");
        File outputDir = new File("models/gltf");
        outputDir.mkdirs();

        GltfSaveOptions saveOpts = new GltfSaveOptions();
        saveOpts.setPrettyPrint(true);

        File[] objFiles = inputDir.listFiles(
            (dir, name) -> name.toLowerCase().endsWith(".obj")
        );

        if (objFiles == null) return;

        for (File objFile : objFiles) {
            String baseName = objFile.getName()
                .replaceFirst("\\.obj$", "");

            Scene scene = Scene.fromFile(objFile.getAbsolutePath());
            String outPath = new File(outputDir, baseName + ".gltf")
                .getAbsolutePath();

            scene.save(outPath, saveOpts);
            System.out.println("Converted: " + objFile.getName()
                + " -> " + baseName + ".gltf");
        }
    }
}

Esto carga cada .obj archivo en un directorio, convierte cada uno a glTF con salida formateada de forma legible y guarda los resultados. Puedes adaptar este patrón para cualquier combinación de formato de origen y destino.

Referencia de Conversión entre Formatos

La tabla siguiente muestra qué esperar al convertir entre formatos.

Directrices Generales de Conversión

• Geometría generalmente se conserva entre pares de formatos, con una excepción importante: al exportar a STL, las mallas deben consistir únicamente de caras triangulares. Binary STL trunca silenciosamente caras quad y n-gon a sus primeros 3 vértices; ASCII STL produce una salida malformada para caras que no son triángulos.
• Materiales sobreviven mejor entre escenas importadas de glTF y FBX que incluyen datos de material. Convertir a STL siempre elimina los materiales. Convertir a OBJ simplifica los materiales al modelo básico MTL.
• Jerarquía de escena se conserva entre archivos de formato glTF. OBJ y STL generan estructuras planas. La jerarquía FBX y la extracción de materiales no están completamente verificadas en esta versión.

Juntándolo Todo

Aquí hay un ejemplo completo que carga un archivo OBJ, inspecciona sus nodos y exporta tanto a glTF como a GLB:

import com.aspose.threed.*;

public class FormatWorkflow {
    public static void main(String[] args) throws Exception {
        // Load
        Scene scene = Scene.fromFile("input.obj");

        // Inspect
        System.out.println("Nodes in scene:");
        for (Node child : scene.getRootNode().getChildNodes()) {
            System.out.println("  " + child.getName());
            Transform t = child.getTransform();
            System.out.println("    Translation: "
                + t.getTranslation());
        }

        // Export to glTF with options
        GltfSaveOptions gltfOpts = new GltfSaveOptions();
        gltfOpts.setPrettyPrint(true);
        scene.save("output.gltf", gltfOpts);

        // Export to GLB (binary glTF)
        GltfSaveOptions glbOpts = new GltfSaveOptions();
        glbOpts.setContentType(FileContentType.BINARY);
        scene.save("output.glb", glbOpts);

        System.out.println("Export complete.");
    }
}

Resumen

Aspose.3D FOSS para Java te brinda una API consistente a través de múltiples formatos. Los puntos clave:

• OBJ – intercambio simple de mallas con materiales básicos.
• STL – formato solo de geometría para flujos de trabajo de impresión 3D.
• glTF / GLB – formato moderno compatible con PBR para uso web y en tiempo real. Use GltfSaveOptions con setContentType(FileContentType.BINARY) para salida GLB.
• FBX – solo de importación; formato rico para cargar activos desde motores de juego y herramientas DCC.

Utilice clases de opciones de carga y guardado específicas del formato (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptions) cuando necesite un control granular sobre el proceso de importación o exportación.

Para más detalles, visite el Aspose.3D documentación o explore el código fuente en GitHub.