Presentant Aspose.3D FOSS per a .NET

Estem encantats d’anunciar la disponibilitat de Aspose.3D FOSS per a .NET – una biblioteca gratuïta i de codi obert per treballar amb formats de fitxers 3D en aplicacions .NET. Construïda com una solució pura en C# sense dependències natives, la biblioteca apunta a .NET 10.0 i posteriors, fent-la accessible a una àmplia gamma de projectes i entorns.

Aquest article explica què ofereix la biblioteca, com començar i cap a on dirigir-se a continuació.

Què és Aspose.3D FOSS per a .NET?

Aspose.3D FOSS per a .NET és una biblioteca lleugera de processament de fitxers 3D publicada sota la llicència MIT. Proporciona una API de gràfic d’escena que permet carregar, inspeccionar, transformar i desar models 3D en diversos formats àmpliament utilitzats. La biblioteca està completament escrita en C# i no requereix binaris natius externs ni configuracions específiques de plataforma.

El codi font està disponible a GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Aspectes clau

• C# pur – sense P/Invoke, sense biblioteques natives, sense restriccions de plataforma.
• .NET 10.0+ compatible.
• Llicència MIT – utilitzeu-lo en projectes personals, comercials o propietaris sense restriccions.
• Arquitectura de graf d’escena – un arbre familiar de nodes, malles, càmeres i materials.
• Suport multiformat – llegiu i escriviu fitxers OBJ, STL, glTF 2.0, GLB, FBX, Collada i 3MF.

Inici ràpid

Instal·lació de NuGet

Afegiu el paquet NuGet al vostre projecte:

dotnet add package Aspose.3D --version 26.1.0

La vostra primera conversió

El cas d’ús més senzill és carregar un fitxer 3D en un format i desar-lo en un altre. Aquí teniu una conversió de dues línies d’OBJ a STL:

using Aspose.ThreeD;

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

La Scene class és el punt d’entrada central. Crida scene.Open() amb una ruta de fitxer per carregar un model, després crida Save() amb la ruta de destinació. La biblioteca infereix el format a partir de l’extensió del fitxer.

Construint una escena des de zero

També pots construir escenes de manera programàtica:

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

Això crea una nova escena, afegeix una primitiva de caixa com a node fill sota l’arrel, la posiciona a les coordenades (1, 2, 3) i exporta el resultat com a fitxer glTF.

Carregant amb opcions específiques del format

Quan necessites un control més gran sobre el procés de càrrega, cada format ofereix una classe d’opcions dedicada. Per exemple, carregar un fitxer STL amb opcions explícites:

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() method accepta qualsevol dels tipus d’opció de càrrega: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, o TmfLoadOptions.

Recorregut del gràfic d’escena

Un cop una escena està carregada, pots recórrer l’arbre de nodes per inspeccionar o modificar el seu contingut:

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

Aquest patró és útil per depurar, generar informes sobre el contingut del model o modificar selectivament parts d’una escena abans de tornar a exportar.

Aplicació de transformacions

El posicionament de nodes en l’espai 3D es fa a través del Transform propietat a 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");

Les transformacions segueixen el model estàndard d’herència pare-fill: la posició en l’espai mundial d’un fill és la combinació de la seva transformació local i totes les transformacions dels ancestres fins a l’arrel.

Què s’inclou

La biblioteca ve amb un conjunt enfocat de funcionalitats dissenyat al voltant del model de gràfic d’escena 3D.

Gràfic d’escena

El gràfic de escena és l’esquena dorsal de l’API. Cada fitxer 3D es representa com una estructura d’arbre:

Primitius integrats

L’edició .NET inclou classes de formes paramètriques que es poden adjuntar directament a nodes o convertir a Mesh:

• Cub – caixa alineada amb els eixos amb amplada, alçada i profunditat configurables.
• Esfera – esfera paramètrica amb radi configurable.
• Cilindre – cilindre paramètric amb radis i alçada configurables.

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

Materials

La biblioteca ofereix diversos tipus de material:

• LambertMaterial – material clàssic només difús amb components de color ambient, difús, emissiu i reflectant.
• PhongMaterial – amplia Lambert amb reflexos especulars i brillantor.
• PbrMaterial – material de renderització basat en la física amb color base, metàl·lic, rugositat, oclusió i ranures de textures.

Utilitats Matemàtiques

El Aspose.ThreeD l’espai de noms inclou primitives matemàtiques essencials:

• FVector3 – vector de 3 components de precisió simple per a posicions, direccions i escala. Utilitzat per Transform.Translation i Transform.Scale.
• Vector4 – vector de 4 components de precisió simple per a punts de control i normals.
• Matrix4 – matriu de transformació 4x4.
• Quaternion – representació de rotació. Utilitzat per Transform.Rotation.
• BoundingBox – caixa delimitadora alineada amb l’eix per a consultes espacials.

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

Opcions de càrrega i desament

Cada format té classes d’opcions dedicades que et permeten controlar el comportament d’importació i exportació:

Per exemple, per carregar un fitxer OBJ amb inversió de coordenades i normalització de normals:

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

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

Formats compatibles

La taula següent resumeix els formats que Aspose.3D FOSS per a .NET pot llegir i escriure.

Guia de selecció de formats

Escollir el format adequat depèn del teu cas d’ús:

• OBJ és ideal quan necessites la màxima compatibilitat entre eines 3D. Gairebé qualsevol aplicació de modelatge pot llegir i escriure OBJ. Funciona bé per a l’intercanvi de dades de malla però només transporta informació bàsica de materials a través dels fitxers MTL associats.
• STL és el format escollit per als fluxos de treball d’impressió 3D. Emmagatzema geometria triangulada en brut sense materials ni jerarquia d’escena, que és exactament el que espera el programari de laminació.
• glTF és l’estàndard modern per al web i el 3D en temps real. Admet materials PBR, jerarquies d’escena completes i està dissenyat per a una transmissió eficient. Utilitza glTF quan construeix visualitzadors basats en web o apunts a qualsevol pipeline de renderització en temps real.
• FBX està profundament integrat en els fluxos de treball de desenvolupament de jocs i creació de contingut digital. Admet dades d’escena riques, incloent jerarquies i materials. Aspose.3D FOSS per a .NET admet FBX importació i exportació en modes ASCII i binari.
• 3MF és un format modern d’impressió 3D que admet metadades riques, materials i escenes multiobjecte en un únic paquet basat en ZIP.

Limitacions conegudes

Scene.Render() és no és compatible a l’edició FOSS. Cridar aquest mètode generarà una NotImplementedException. La biblioteca està dissenyada per al processament 3D basat en fitxers – càrrega, manipulació, transformació i desament de models – més que per al renderitzat en temps real a una pantalla.

Codi obert i llicència

Aspose.3D FOSS per a .NET es publica sota la MIT License. Això vol dir que sou lliure de:

• Utilitzar la biblioteca en aplicacions comercials i propietàries.
• Modifiqueu el codi font per adaptar-lo a les vostres necessitats.
• Distribuïu la biblioteca com a part del vostre propi programari.

No hi ha cap taxa de regalies, cap límit d’ús i cap requisit d’atribució més enllà del que especifica la llicència MIT.

El codi font complet està allotjat a GitHub, i les contribucions són benvingudes: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Requisits del sistema

Com començar

Aquí teniu els recursos per ajudar-vos a posar-vos en marxa:

• Documentació – guies completes i recorreguts d’API estan disponibles a la site de documentació Aspose.3D.
• Base de coneixement – articles pràctics de com fer i consells de resolució de problemes a la Aspose.3D KB.
• Referència d’API – referència detallada de classes i mètodes a la Referència de l’API Aspose.3D.
• Codi font – navega i contribueix a GitHub.
• NuGet – el paquet es publica com a Aspose.3D a NuGet.

Casos d’ús comuns

Aquí teniu alguns escenaris pràctics on Aspose.3D FOSS per a .NET s’adapta bé:

Fluxos de conversió de formats

Moltes equips reben actius 3D en un format però els necessiten en un altre. Un equip de disseny pot treballar amb FBX mentre que l’equip web necessita glTF. La biblioteca us permet crear fluxos de conversió automatitzats:

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

Abans d’integrar un recurs 3D a la teva aplicació, potser voldràs validar-ne el contingut – comprovant el nombre de nodes, verificant la geometria o confirmant que els elements esperats estan presents:

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

Muntatge d’Escena

Pots carregar diversos models i combinar-los 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è ve a continuació

En les properes publicacions, cobrirem:

• Una anàlisi profunda de les característiques clau de l’API de gràfic d’escenes, materials i utilitats matemàtiques.
• Una guia pràctica per treballar amb cada format 3D compatible – OBJ, STL, glTF, FBX i 3MF – incloent opcions de càrrega/descarrega i patrons de conversió per lots.

Estigueu atents, i no dubteu a explorar la biblioteca i compartir els vostres comentaris a GitHub.