Introdução Aspose.3D FOSS para Java

Estamos ansiosos para anunciar a disponibilidade de Aspose.3D FOSS para Java - uma biblioteca de código aberto livre para trabalhar com formatos de arquivo 3D em aplicações Java. Construída como uma solução pura Java sem dependências nativas, a biblioteca funciona no Java 21 e mais tarde, tornando-a acessível a uma ampla gama de projetos e ambientes.

Este post passa por o que a biblioteca oferece, como começar e onde ir de aqui.

O que é o 3D FOSS para Java?

Aspose.3D FOSS para Java é uma biblioteca de processamento de arquivos 3D leve publicada sob o Licença de Mito.Ele fornece uma API de gráficos que permite carregar, inspeccionar, transformar e salvar modelos 3D em vários formatos amplamente utilizados.A biblioteca é totalmente escrita em Java e não requer binárias nativas externas ou configurações específicas da plataforma.

O código fonte está disponível no GitHub: WEB WEB www.github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Cabe destacar

• Afinal, Java - sem JNI, nenhuma biblioteca nativa, não restrições da plataforma.
• Java 21+ em inglês compatível .
• MIT licenciado - utilizá-lo em projetos pessoais, comerciais ou propriedadeis sem restrições.
• Arquitetura Scene-Graph - Uma árvore familiar de nodos, mesas, câmeras e materiais.
• Suporte em Multi-Format - Leia e escreva arquivos OBJ, STL, glTF 2.0 e GLB; leia os arquivo FBX.

Início rápido

Maven instalação

Adicione a seguinte dependência ao seu pom.xml:

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

Sua primeira conversão

O caso mais simples de uso é carregar um arquivo 3D em um formato e economizá-lo noutro. Aqui está uma conversão de duas linhas do OBJ para 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");
    }
}

O que Scene A classe é o ponto de entrada central.Calho Scene.fromFile() com um caminho de arquivo para carregar um modelo, em seguida chame save() A biblioteca infere o formato da extensão de arquivo.

Construindo uma cena de Scratch

Você também pode criar cenas programaticamente:

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

Isso cria uma nova cena, adiciona um nodo infantil chamado “Caixa” debaixo da raiz, posicionando-o em coordenadas (1, 2, 3), e exporta o resultado como um arquivo glTF.

Carregar com opções específicas de formato

Quando você precisa de um controle mais fino sobre o processo de carregamento, cada formato fornece uma classe de opções dedicada. Por exemplo, carrega um arquivo STL com opção explícita:

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

O que Scene.fromFile() O método estático aceita qualquer um dos tipos de opções de carga: ObjLoadOptions, StlLoadOptions, GltfLoadOptions,ou FbxLoadOptions.

Passando pelo gráfico da cena

Uma vez que uma cena é carregada, você pode andar pela árvore de nodo para inspeccionar ou modificar seu conteúdo:

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 padrão é útil para desligar, gerar relatórios sobre conteúdo de modelo ou modificar seletivamente partes de uma cena antes de reexportar.

Aplicando Transformes

A posição de nódulos no espaço 3D é feita através do Transform Objetos em cada um 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");
    }
}

As transformações seguem o padrão de herança parental-fim: a posição do mundo-espaço da criança é a combinação de sua transformação local e todos os ancestrais transformam até à raiz.

O que está incluído

A biblioteca embarca com um conjunto focado de capacidades projetadas em torno do modelo 3D-escena-graf.

Escena de Graph

O gráfico de cena é o fundo da API. Cada arquivo 3D é representado como uma estrutura árvore:

Materiais

A biblioteca fornece um modelo de material PBR (Rendering Físicamente Baseado):

• PbrMaterial - material de renderização fisicamente baseado com albedo, metalicidade, rigidez, cor emissiva e transparência. esta é a única classe de material concreto disponível na edição Java.

Utilidades Matemáticas

O que com.aspose.threed O pacote inclui primitivas matemáticas essenciais:

• Vector 3 - Vector de 3 componentes para posições, direções e cores.
• Matriz 4 - 4x4 Matriz de transformação.
• Quaternão - A representação de rotação.
• BoundingBox - Caixa de ligação axis para consultas espaciais.

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

Carregar e salvar opções

Cada formato tem aulas de opções dedicadas que permitem controlar o comportamento de importação e exportação:

Por exemplo, para exportar glTF com JSON impresso e um sistema de coordenadas flipped:

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

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

Formatos suportados

A tabela seguinte resume os formatos que Aspose.3D FOSS para Java pode ler e escrever.

OBJ, STL, glTF e GLB suportam tanto carregamento como poupança. FBX é apoiado para importação apenas.

Guia de seleção do formato

Escolher o formato certo depende do seu caso de uso:

• OBJ É ideal quando você precisa de máxima compatibilidade entre ferramentas 3D. Quase todas as aplicações de modelagem podem ler e escrever OBJ. Ele funciona bem para o intercâmbio de dados de mesh, mas apenas traz informações básicas sobre materiais através dos arquivos MTL companheiros.
• STL É o formato de escolha para fluxos de trabalho de impressão 3D. Ele armazena geometria triangulada cru sem materiais ou hierarquia da cena, que é exatamente o que o software de esboço espera. Se seu tubo termina em uma impressora 3d, STL é a opção simples.
• GSTF É o padrão moderno para a web e 3D em tempo real. Ele suporta materiais PBR, hierarquias de cena completa, e é projetado para uma transmissão eficiente. Use glTF quando construir espectadores baseados na web, trabalhar com three.js ou Babylon.JS, ou direcionar qualquer pipeline de renderização em Tempo Real.
• FBX é profundamente integrado no desenvolvimento de jogos e fluxos de trabalho para a criação de conteúdo digital. suporta dados ricos em cenários, incluindo hierarquias e materiais. Aspose.3D FOSS para Java suporta FBX Só importação - Use-o para carregar ativos FBX e converter-os em outros formatos.

Limitações conhecidas

É importante notar que Scene.render() É Não apoiado A partir da edição do FOSS, o chamado método vai lançar um UnsupportedOperationException.A biblioteca é projetada para processamento 3D baseado em arquivos - carregando, manipulando e transformando modelos - em vez de renderizar em tempo real a uma tela.

Fonte aberta e licença

Aspose.3D FOSS para Java é lançado sob o Licença MIT.Isso significa que você é livre para:

• Use a biblioteca em aplicações comerciais e de propriedade.
• Modificar o código fonte para atender às suas necessidades.
• Distribuir a biblioteca como parte do seu próprio software.

Não há taxas de royalties, não há limites de uso e não existem requisitos de atribuição além do que a licença MIT especifica.

O código fonte completo é hospedado no GitHub, e as contribuições são bem-vindas: WEB WEB www.github.com/aspose-3d-foss/Aspose.3D-FOSS-for-Java

Requisitos do sistema

Começando com

Aqui estão os recursos para ajudá-lo a subir e correr:

• Documentário - Guia abrangente e caminhos API estão disponíveis no Web site de documentação 3D.
• Base de conhecimento - práticas como-para artigos e dicas de resolução de problemas no Avaliação 3D KB.
• Referência de API - Referência de classe e método em detalhes à Aspose.3D API Referência.
• Código de Fonte - Brows e contribui para GitHub.
• Maven Central - o pacote é publicado como org.aspose:aspose-3d-foss:26.5.0 em Maven Central.

Casos de uso comum

Aqui estão alguns cenários práticos onde Aspose.3D FOSS para Java se encaixa bem:

Formato de conversão de tubos

Muitas equipes recebem ativos 3D em um formato, mas precisam deles em outro. Uma equipe de design pode trabalhar no FBX enquanto a equipa da web precisa do glTF. A biblioteca permite que você construa tubos automatizados de conversão:

// 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 um ativo 3D em sua aplicação, você pode querer validar seu conteúdo - verificar os conteúdos de nódulos, verificar geometria ou confirmar que os elementos esperados estão 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");
    }
}

Assembleia de cena

Você pode carregar vários modelos e combinar-os em uma única cena:

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

O que é o próximo

Nos próximos posts, vamos cobrir:

• Um mergulho profundo nas características-chave da API de gráficos, materiais e utilidades matemáticas.
• Um guia prático para trabalhar com cada formato 3D suportado - OBJ, STL, glTF e FBX - incluindo opções de carga/salvação e padrões de conversão de batch.

Fique atento e sinta-se livre para explorar a biblioteca e compartilhar seu feedback no GitHub.