Trabalhando com Formatos de Arquivo 3D em Java usando Aspose.3D FOSS

Aspose.3D FOSS para Java suporta cinco formatos de arquivo 3D: OBJ, STL, glTF, GLB, e FBX (apenas importação).

Todos os exemplos usam o com.aspose.threed.* pacote:

import com.aspose.threed.*;

Dependência Maven:

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

Visão geral dos formatos

Antes de mergulhar, aqui está uma visão geral rápida dos quatro formatos suportados e seus casos de uso típicos.

OBJ, STL, glTF, e GLB suportam tanto importação quanto exportação. FBX é suportado apenas para apenas importação. GLB (binary glTF) é produzido via GltfSaveOptions com setContentType(FileContentType.BINARY).

OBJ: Wavefront Object

OBJ é um dos formatos de malha 3D mais amplamente suportados. Ele armazena a geometria como texto simples, com um opcional .mtl arquivo complementar para materiais.

Carregando arquivos OBJ

A abordagem mais simples é passar o caminho do arquivo diretamente:

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

Para mais controle, use ObjLoadOptions:

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

Quando o arquivo OBJ referencia um arquivo MTL (via um mtllib diretiva), a biblioteca tentará carregar as definições de material dele automaticamente. O arquivo MTL deve estar no mesmo diretório que o arquivo OBJ ou no caminho especificado na diretiva.

Salvando como OBJ

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

Casos de Uso do OBJ

• Troca de dados de malha entre diferentes ferramentas 3D.
• Importando modelos de bibliotecas de ativos que distribuem no formato OBJ.
• Inspeção rápida da geometria sem hierarquias de cena complexas.

STL: Estereolitografia

STL é o formato padrão para impressão 3D. Ele representa geometria triangulada bruta sem materiais, cores ou hierarquia de cena. Arquivos STL vêm em duas variantes: ASCII (legível por humanos) e binário (compacto).

Carregando Arquivos STL

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

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

Salvando como STL

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

Para controlar a saída, use StlSaveOptions:

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

Considerações sobre STL

• Arquivos STL contêm apenas geometria triangulada. Materiais, texturas e a hierarquia da cena são perdidos durante a exportação.
• STL binário é significativamente menor que STL ASCII para modelos grandes.
• STL é o formato preferido quando o alvo é uma impressora 3D ou um software de fatiamento.

glTF: Formato de Transmissão GL

glTF é um formato moderno projetado para transmissão e carregamento eficientes de conteúdo 3D, particularmente na web e em aplicações em tempo real. Ele suporta materiais PBR, hierarquias de cena e animações.

Carregando arquivos glTF

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

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

Salvando como glTF

A gravação básica usa a extensão do arquivo para determinar o formato:

scene.save("output.gltf");

Para controle detalhado, use GltfSaveOptions:

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

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

Detalhes do GltfSaveOptions

Casos de uso do glTF

• Visualizadores 3D baseados na web (three.js, Babylon.js).
• Aplicações em tempo real e motores de jogo.
• Preservando definições de materiais PBR entre ferramentas.

FBX: Filmbox (Somente Importação)

FBX é um formato proprietário da Autodesk que é amplamente usado no desenvolvimento de jogos e na criação de conteúdo digital. Ele suporta hierarquias de cena ricas, materiais e animações. Aspose.3D FOSS para Java suporta FBX para apenas importação – exportar para FBX não está disponível.

Carregando arquivos FBX

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

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

Convertendo FBX para outros formatos

Como a exportação de FBX não é suportada, converta cenas FBX importadas para glTF, GLB, OBJ ou 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 do FBX

• Importando ativos das ferramentas Autodesk (Maya, 3ds Max) e convertendo para outros formatos.
• Carregando personagens com rig e cenas animadas para reexportação para glTF/GLB.

Conversão em lote.

Um fluxo de trabalho comum é converter um diretório inteiro de arquivos de um formato para outro. Aqui está um padrão para conversão em lote:

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

Isso carrega cada .obj arquivo em um diretório, converte cada um para glTF com saída formatada de forma legível e salva os resultados. Você pode adaptar esse padrão para qualquer combinação de formato de origem e destino.

Referência de Conversão entre Formatos.

A tabela a seguir mostra o que esperar ao converter entre formatos.

Diretrizes Gerais de Conversão.

• Geometria é sempre preservado em todos os pares de formatos.
• Materiais sobrevivem melhor entre glTF e FBX, que ambos suportam modelos de material ricos. Converter para STL sempre elimina os materiais. Converter para OBJ simplifica os materiais para o modelo MTL básico.
• Hierarquia de cena é preservada entre glTF e FBX. OBJ e STL produzem estruturas planas.

Juntando Tudo

Aqui está um exemplo completo que carrega um arquivo OBJ, inspeciona seus nós e exporta tanto para glTF quanto para 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.");
    }
}

Resumo

Aspose.3D FOSS for Java oferece uma API consistente em vários formatos. Os pontos principais:

• OBJ – troca simples de malha com materiais básicos.
• STL – formato apenas de geometria para pipelines de impressão 3D.
• glTF / GLB – formato moderno compatível com PBR para uso web e em tempo real. Use GltfSaveOptions com setContentType(FileContentType.BINARY) para saída GLB.
• FBX – apenas importação; formato rico para carregar ativos de motores de jogo e ferramentas DCC.

Use classes de opções de carregamento e salvamento específicas do formato (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptions) quando precisar de controle granular sobre o processo de importação ou exportação.

Para mais detalhes, visite o documentação Aspose.3D ou navegue o código-fonte em GitHub.