Apresentando Aspose.3D FOSS para .NET

Estamos entusiasmados em anunciar a disponibilidade de Aspose.3D FOSS for .NET – uma biblioteca gratuita e de código aberto para trabalhar com formatos de arquivos 3D em aplicações .NET. Desenvolvida como uma solução pura em C# sem dependências nativas, a biblioteca tem como alvo .NET 10.0 e posteriores, tornando-a acessível a uma ampla gama de projetos e ambientes.

Este post percorre o que a biblioteca oferece, como começar e para onde ir a partir daqui.

O que é Aspose.3D FOSS para .NET?

Aspose.3D FOSS for .NET é uma biblioteca leve de processamento de arquivos 3D publicada sob a licença MIT. Ela fornece uma API de grafo de cena que permite carregar, inspecionar, transformar e salvar modelos 3D em vários formatos amplamente usados. A biblioteca é totalmente escrita em C# e não requer binários nativos externos ou configurações específicas de plataforma.

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

Principais Destaques

• C# puro – sem P/Invoke, sem bibliotecas nativas, sem restrições de plataforma.
• .NET 10.0+ compatível.
• Licença MIT – use-o em projetos pessoais, comerciais ou proprietários sem restrições.
• Arquitetura de grafo de cena – uma árvore familiar de nós, malhas, câmeras e materiais.
• Suporte a múltiplos formatos – leia e escreva arquivos OBJ, STL, glTF 2.0, GLB, FBX, Collada e 3MF.

Início Rápido

Instalação via NuGet

Adicione o pacote NuGet ao seu projeto:

dotnet add package Aspose.3D --version 26.1.0

Sua Primeira Conversão

O caso de uso mais simples é carregar um arquivo 3D em um formato e salvá-lo em outro. Aqui está uma conversão de duas linhas de OBJ para STL:

using Aspose.ThreeD;

var scene = new Scene();
scene.Open("cube.obj");
scene.Save("output.stl");

A Scene classe é o ponto de entrada central. Chame scene.Open() com um caminho de arquivo para carregar um modelo, então chame Save() com o caminho de destino. A biblioteca infere o formato a partir da extensão do arquivo.

Construindo uma Cena do Zero

Você também pode construir cenas programaticamente:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();
var box = new Box(2, 2, 2);
var node = scene.RootNode.CreateChildNode("Box", box);

node.Transform.Translation = new FVector3(1, 2, 3);

scene.Save("scene.gltf");

Isso cria uma nova cena, adiciona um primitivo de caixa como nó filho sob a raiz, posiciona‑o nas coordenadas (1, 2, 3) e exporta o resultado como um arquivo glTF.

Carregando com Opções Específicas de Formato

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

using Aspose.ThreeD;
using Aspose.ThreeD.Formats;

var scene = new Scene();
var opts = new StlLoadOptions();
scene.Open("part.stl", opts);

// Inspect the loaded scene
Console.WriteLine("Root children: " + scene.RootNode.ChildNodes.Count);

// Re-export as OBJ
scene.Save("part.obj");

O scene.Open() method aceita qualquer um dos tipos de opção de carregamento: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, ou TmfLoadOptions.

Percorrendo o Grafo de Cena

Depois que uma cena é carregada, você pode percorrer a árvore de nós para inspecionar ou modificar seu conteúdo:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();
scene.Open("model.gltf");

foreach (var child in scene.RootNode.ChildNodes)
{
    Console.WriteLine("Node: " + child.Name);
    Console.WriteLine("  Translation: " + child.Transform.Translation);

    if (child.Entity is Mesh mesh)
    {
        Console.WriteLine("  Vertices: " + mesh.ControlPoints.Count);
    }
}

Esse padrão é útil para depuração, geração de relatórios sobre o conteúdo do modelo ou modificação seletiva de partes de uma cena antes de reexportar.

Aplicando Transformações

Posicionar nós no espaço 3D é feito através do Transform propriedade em cada Node:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();

var parent = scene.RootNode.CreateChildNode("Parent");
parent.Transform.Translation = new FVector3(10, 0, 0);

var child = parent.CreateChildNode("Child");
child.Transform.Translation = new FVector3(5, 0, 0);
child.Transform.Scale = new FVector3(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 modelo padrão de herança pai‑filho: a posição em espaço mundial de um filho é a combinação de sua transformação local e de todas as transformações dos ancestrais até a raiz.

O que está incluído

A biblioteca vem com um conjunto focado de recursos projetados em torno do modelo de grafo de cena 3D.

Grafo de Cena

O grafo de cena é a espinha dorsal da API. Cada arquivo 3D é representado como uma estrutura de árvore:

Primitivas Incorporadas

A edição .NET inclui classes de formas paramétricas que podem ser anexadas diretamente a nós ou convertidas para Mesh:

• Caixa – caixa alinhada aos eixos com largura, altura e profundidade configuráveis.
• Esfera – esfera paramétrica com raio configurável.
• Cilindro – cilindro paramétrico com raios e altura configuráveis.

var sphere = new Sphere(1);
var mesh = sphere.ToMesh();
Console.WriteLine("Vertices: " + mesh.ControlPoints.Count);

Materiais

A biblioteca fornece vários tipos de material:

• LambertMaterial – material clássico apenas difuso com componentes de cor ambiente, difusa, emissiva e reflexiva.
• PhongMaterial – estende Lambert com realces especulares e brilho.
• PbrMaterial – material de renderização baseada em física com cor base, metalicidade, rugosidade, oclusão e slots de textura.

Utilitários Matemáticos

O Aspose.ThreeD namespace inclui primitivas matemáticas essenciais:

• FVector3 – vetor de 3 componentes de precisão simples para posições, direções e escala. Usado por Transform.Translation e Transform.Scale.
• Vector4 – vetor de 4 componentes de precisão simples para pontos de controle e normais.
• Matrix4 – matriz de transformação 4x4.
• Quaternion – representação de rotação. Usado por Transform.Rotation.
• BoundingBox – caixa delimitadora alinhada aos eixos para consultas espaciais.

var a = new FVector3(1, 0, 0);
var b = new FVector3(0, 1, 0);
// Vector operations for spatial computations

Opções de Carregamento e Salvamento

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

Por exemplo, para carregar um arquivo OBJ com inversão de coordenadas e normalização de normais:

var opts = new ObjLoadOptions();
opts.FlipCoordinateSystem = true;
opts.NormalizeNormal = true;

scene.Open("model.obj", opts);

Formatos Compatíveis

A tabela a seguir resume os formatos que Aspose.3D FOSS para .NET pode ler e gravar.

Guia de Seleção de Formato

Escolher o formato correto depende do seu caso de uso:

• OBJ é ideal quando você precisa de máxima compatibilidade entre ferramentas 3D. Quase todo aplicativo de modelagem pode ler e gravar OBJ. Funciona bem para troca de dados de malha, mas transporta apenas informações básicas de material através de arquivos MTL acompanhantes.
• STL é o formato preferido para fluxos de trabalho de impressão 3D. Ele armazena geometria triangulada bruta sem materiais ou hierarquia de cena, que é exatamente o que o software de fatiamento espera.
• glTF é o padrão moderno para web e 3D em tempo real. Suporta materiais PBR, hierarquias completas de cena e foi projetado para transmissão eficiente. Use glTF ao construir visualizadores baseados na web ou ao direcionar qualquer pipeline de renderização em tempo real.
• FBX está profundamente integrado aos fluxos de trabalho de desenvolvimento de jogos e criação de conteúdo digital. Suporta dados de cena ricos, incluindo hierarquias e materiais. Aspose.3D FOSS para .NET suporta FBX importar e exportar em modos ASCII e binário.
• 3MF é um formato moderno de impressão 3D que suporta metadados ricos, materiais e cenas com múltiplos objetos em um único pacote baseado em ZIP.

Limitações Conhecidas

Scene.Render() é não suportado na edição FOSS. Chamar este método lançará um NotImplementedException. A biblioteca foi projetada para processamento 3D baseado em arquivos – carregamento, manipulação, transformação e salvamento de modelos – em vez de renderização em tempo real para um display.

Código Aberto e Licenciamento

Aspose.3D FOSS for .NET é lançado sob a MIT License. Isso significa que você está livre para:

• Usar a biblioteca em aplicações comerciais e proprietárias.
• Modifique o código-fonte para atender às suas necessidades.
• Distribua a biblioteca como parte do seu próprio software.

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

O código-fonte completo está hospedado no GitHub, e contribuições são bem-vindas: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Requisitos do Sistema

Começando

Aqui estão os recursos para ajudá-lo a começar:

• Documentação – guias abrangentes e tutoriais de API estão disponíveis no Aspose.3D site de documentação.
• Base de Conhecimento – artigos práticos de como‑fazer e dicas de solução de problemas na Aspose.3D KB.
• Referência da API – referência detalhada de classes e métodos no Referência da API Aspose.3D.
• Código-fonte – navegue e contribua em GitHub.
• NuGet – o pacote é publicado como Aspose.3D no NuGet.

Casos de Uso Comuns

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

Pipelines de Conversão de Formato

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

using Aspose.ThreeD;
using Aspose.ThreeD.Formats;

// Convert all incoming FBX assets to GLB for the web team
var scene = new Scene();
scene.Open("asset.fbx");

scene.Save("asset.glb");

3D Model Inspection and Validation

Antes de integrar um ativo 3D em sua aplicação, você pode querer validar seu conteúdo — verificando a contagem de nós, confirmando a geometria ou assegurando que os elementos esperados estejam presentes:

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;

var scene = new Scene();
scene.Open("model.obj");

int nodeCount = scene.RootNode.ChildNodes.Count;
Console.WriteLine("Top-level nodes: " + nodeCount);

foreach (var child in scene.RootNode.ChildNodes)
{
    if (child.Entity is Mesh mesh)
    {
        Console.WriteLine(child.Name + ": "
            + mesh.ControlPoints.Count + " vertices");
    }
}

Montagem da Cena

Você pode carregar vários modelos e combiná‑los em uma única cena:

using Aspose.ThreeD;

var scene = new Scene();

var part1 = new Scene();
part1.Open("chassis.obj");

var part2 = new Scene();
part2.Open("wheels.obj");

// Add nodes from each part into the combined scene
foreach (var child in part1.RootNode.ChildNodes)
{
    scene.RootNode.ChildNodes.Add(child);
}
foreach (var child in part2.RootNode.ChildNodes)
{
    scene.RootNode.ChildNodes.Add(child);
}

scene.Save("assembled.gltf");

Próximos passos

Nos próximos posts, abordaremos:

• Uma análise aprofundada dos recursos principais da API de grafo de cena, materiais e utilitários matemáticos.
• Um guia prático para trabalhar com cada formato 3D suportado — OBJ, STL, glTF, FBX e 3MF — incluindo opções de carregamento/salvamento e padrões de conversão em lote.

Fique ligado, e sinta‑se à vontade para explorar a biblioteca e compartilhar seu feedback no GitHub.