Presentando Aspose.3D FOSS para .NET

Nos complace anunciar la disponibilidad de Aspose.3D FOSS for .NET – una biblioteca gratuita y de código abierto para trabajar con formatos de archivos 3D en aplicaciones .NET. Construida como una solución pura en C# sin dependencias nativas, la biblioteca tiene como objetivo .NET 10.0 y posteriores, lo que la hace accesible a una amplia gama de proyectos y entornos.

Esta publicación recorre lo que ofrece la biblioteca, cómo comenzar y a dónde ir a partir de aquí.

¿Qué es Aspose.3D FOSS para .NET?

Aspose.3D FOSS for .NET es una biblioteca ligera de procesamiento de archivos 3D publicada bajo la licencia MIT. Proporciona una API de grafo de escena que le permite cargar, inspeccionar, transformar y guardar modelos 3D en varios formatos ampliamente utilizados. La biblioteca está escrita completamente en C# y no requiere binarios nativos externos ni configuraciones específicas de plataforma.

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

Aspectos clave

• C# puro – sin P/Invoke, sin bibliotecas nativas, sin restricciones de plataforma.
• .NET 10.0+ compatible.
• Licencia MIT – úsalo en proyectos personales, comerciales o propietarios sin restricciones.
• Arquitectura de grafo de escena – un árbol familiar de nodos, mallas, cámaras y materiales.
• Soporte multi-formato – leer y escribir archivos OBJ, STL, glTF 2.0, GLB, FBX, Collada y 3MF.

Inicio rápido

Instalación de NuGet

Agregue el paquete NuGet a su proyecto:

dotnet add package Aspose.3D --version 26.1.0

Su primera conversión

El caso de uso más simple es cargar un archivo 3D en un formato y guardarlo en otro. Aquí hay una conversión de dos líneas de OBJ a STL:

using Aspose.ThreeD;

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

El Scene clase es el punto de entrada central. Llama a scene.Open() con una ruta de archivo para cargar un modelo, luego llama a Save() con la ruta de destino. La biblioteca infiere el formato a partir de la extensión del archivo.

Construyendo una escena desde cero

También puede construir escenas programáticamente:

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

Esto crea una nueva escena, agrega una primitiva de caja como nodo hijo bajo la raíz, la posiciona en las coordenadas (1, 2, 3) y exporta el resultado como un archivo glTF.

Cargando con opciones específicas de formato

Cuando necesita un control más fino sobre el proceso de carga, cada formato proporciona una clase de opciones dedicada. Por ejemplo, cargar un archivo STL con opciones 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");

El scene.Open() el método acepta cualquiera de los tipos de opción de carga: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, o TmfLoadOptions.

Recorriendo el grafo de escena

Una vez que una escena está cargada, puede recorrer el árbol de nodos para inspeccionar o modificar su contenido:

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

Este patrón es útil para depuración, generar informes sobre el contenido del modelo o modificar selectivamente partes de una escena antes de volver a exportarla.

Aplicando transformaciones

El posicionamiento de nodos en el espacio 3D se realiza a través del Transform propiedad en 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");

Las transformaciones siguen el modelo estándar de herencia padre-hijo: la posición en espacio mundial de un hijo es la combinación de su transformación local y todas las transformaciones de los ancestros hasta la raíz.

Qué está incluido

La biblioteca se entrega con un conjunto enfocado de capacidades diseñadas alrededor del modelo de grafo de escena 3D.

Grafo de escena

El grafo de escena es la columna vertebral de la API. Cada archivo 3D se representa como una estructura de árbol:

Primitivas incorporadas

La edición .NET incluye clases de formas paramétricas que pueden adjuntarse directamente a los nodos o convertirse en Mesh:

• Caja – caja alineada a los ejes con ancho, altura y profundidad configurables.
• Esfera – esfera paramétrica con radio configurable.
• Cilindro – cilindro paramétrico con radios y altura configurables.

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

Materiales

La biblioteca proporciona varios tipos de material:

• LambertMaterial – material clásico solo difuso con componentes de color ambiental, difuso, emisivo y reflectante.
• PhongMaterial – extiende Lambert con reflejos especulares y brillo.
• PbrMaterial – material de renderizado basado en física con color base, metálico, rugosidad, oclusión y ranuras de textura.

Utilidades Matemáticas

El Aspose.ThreeD el espacio de nombres incluye primitivas matemáticas esenciales:

• FVector3 – vector de 3 componentes de precisión simple para posiciones, direcciones y escala. Usado por Transform.Translation y Transform.Scale.
• Vector4 – vector de 4 componentes de precisión simple para puntos de control y normales.
• Matrix4 – matriz de transformación 4x4.
• Quaternion – representación de rotación. Usado por Transform.Rotation.
• BoundingBox – caja delimitadora alineada al eje para consultas espaciales.

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

Opciones de carga y guardado

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

Por ejemplo, para cargar un archivo OBJ con inversión de coordenadas y normalización de normales:

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

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

Formatos compatibles

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

Guía de selección de formatos

Elegir el formato adecuado depende de su caso de uso:

• OBJ es ideal cuando necesitas la máxima compatibilidad entre herramientas 3D. Casi cualquier aplicación de modelado puede leer y escribir OBJ. Funciona bien para el intercambio de datos de malla, pero solo transporta información básica de materiales a través de archivos MTL complementarios.
• STL es el formato preferido para flujos de trabajo de impresión 3D. Almacena geometría triangulada cruda sin materiales ni jerarquía de escena, que es exactamente lo que el software de laminado espera.
• glTF es el estándar moderno para 3D web y en tiempo real. Soporta materiales PBR, jerarquías de escena completas y está diseñado para una transmisión eficiente. Usa glTF al crear visores basados en la web o al dirigirte a cualquier pipeline de renderizado en tiempo real.
• FBX está profundamente integrado en los flujos de trabajo de desarrollo de juegos y creación de contenido digital. Soporta datos de escena ricos, incluidas jerarquías y materiales. Aspose.3D FOSS para .NET soporta FBX importar y exportar en modos ASCII y binario.
• 3MF es un formato de impresión 3D moderno que soporta metadatos ricos, materiales y escenas de múltiples objetos en un único paquete basado en ZIP.

Limitaciones conocidas

Scene.Render() es no soportado en la edición FOSS. Llamar a este método lanzará un NotImplementedException. La biblioteca está diseñada para el procesamiento 3D basado en archivos – cargar, manipular, transformar y guardar modelos – en lugar de renderizado en tiempo real a una pantalla.

Código abierto y licenciamiento

Aspose.3D FOSS para .NET se publica bajo la MIT License. Esto significa que eres libre de:

• Utilizar la biblioteca en aplicaciones comerciales y propietarias.
• Modifica el código fuente para adaptarlo a tus necesidades.
• Distribuye la biblioteca como parte de tu propio software.

No hay tarifas de regalías, ni límites de uso, ni requisitos de atribución más allá de lo que especifica la licencia MIT.

El código fuente completo está alojado en GitHub, y se aceptan contribuciones: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Requisitos del sistema

Comenzando

Aquí tienes los recursos para ayudarte a comenzar:

• Documentación – guías exhaustivas y recorridos de API están disponibles en el Aspose.3D sitio de documentación.
• Base de conocimientos – artículos prácticos de cómo hacerlo y consejos de solución de problemas en el Aspose.3D KB.
• Referencia de API – referencia detallada de clases y métodos en el Referencia de la API Aspose.3D.
• Código fuente – explorar y contribuir en GitHub.
• NuGet – el paquete se publica como Aspose.3D en NuGet.

Casos de uso comunes

Aquí tienes algunos escenarios prácticos donde Aspose.3D FOSS para .NET encaja bien:

Canales de conversión de formatos

Muchos equipos reciben activos 3D en un formato pero los necesitan en otro. Un equipo de diseño puede trabajar en FBX mientras que el equipo web necesita glTF. La biblioteca te permite crear canales de conversión 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 un activo 3D en su aplicación, puede que desee validar su contenido – verificando el recuento de nodos, la geometría, o confirmando que los elementos esperados estén 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");
    }
}

Ensamblaje de Escena

Puede cargar varios modelos y combinarlos en una única escena:

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

Qué sigue

En próximas publicaciones, cubriremos:

• Una inmersión profunda en las características clave de la API de grafo de escena, los materiales y las utilidades matemáticas.
• Una guía práctica para trabajar con cada formato 3D compatible – OBJ, STL, glTF, FBX y 3MF – incluyendo opciones de carga/guardado y patrones de conversión por lotes.

Manténganse al tanto, y siéntanse libres de explorar la biblioteca y compartir sus comentarios en GitHub.