Introduzione a Aspose.3D FOSS per .NET

Siamo entusiasti di annunciare la disponibilità di Aspose.3D FOSS for .NET – una libreria gratuita e open-source per lavorare con formati di file 3D nelle applicazioni .NET. Realizzata come una soluzione pure C# senza dipendenze native, la libreria è destinata a .NET 10.0 e versioni successive, rendendola accessibile a un’ampia gamma di progetti e ambienti.

Questo post illustra cosa offre la libreria, come iniziare e dove andare da qui.

Che cos’è Aspose.3D FOSS per .NET?

Aspose.3D FOSS per .NET è una libreria leggera per l’elaborazione di file 3D pubblicata sotto la licenza MIT. Fornisce un’API a grafo di scena che consente di caricare, ispezionare, trasformare e salvare modelli 3D in diversi formati ampiamente utilizzati. La libreria è interamente scritta in C# e non richiede binari nativi esterni né configurazioni specifiche per piattaforma.

Il codice sorgente è disponibile su GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Punti salienti

• C# puro – nessun P/Invoke, nessuna libreria nativa, nessuna restrizione di piattaforma.
• .NET 10.0+ compatibile.
• con licenza MIT – usalo in progetti personali, commerciali o proprietari senza restrizioni.
• Architettura a grafo di scena – un albero familiare di nodi, mesh, telecamere e materiali.
• Supporto multi-formato – leggere e scrivere file OBJ, STL, glTF 2.0, GLB, FBX, Collada e 3MF.

Avvio rapido

Installazione NuGet

Aggiungi il pacchetto NuGet al tuo progetto:

dotnet add package Aspose.3D --version 26.1.0

La tua prima conversione

Il caso d’uso più semplice è caricare un file 3D in un formato e salvarlo in un altro. Ecco una conversione in due righe da OBJ a STL:

using Aspose.ThreeD;

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

Il Scene La classe è il punto di ingresso centrale. Chiama scene.Open() con un percorso file per caricare un modello, quindi chiama Save() con il percorso di destinazione. La libreria deduce il formato dall’estensione del file.

Creare una scena da zero

Puoi anche costruire scene programmaticamente:

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

Questo crea una nuova scena, aggiunge una primitiva box come nodo figlio sotto la radice, la posiziona alle coordinate (1, 2, 3) ed esporta il risultato come file glTF.

Caricamento con opzioni specifiche per formato

Quando hai bisogno di un controllo più fine sul processo di caricamento, ogni formato fornisce una classe di opzioni dedicata. Ad esempio, caricare un file STL con opzioni esplicite:

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

Il scene.Open() Il metodo accetta uno qualsiasi dei tipi di opzione di caricamento: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, o TmfLoadOptions.

Attraversare il grafo della scena

Una volta che una scena è caricata, puoi percorrere l’albero dei nodi per ispezionare o modificare il suo contenuto:

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

Questo schema è utile per il debug, la generazione di report sul contenuto del modello o la modifica selettiva di parti di una scena prima della riesportazione.

Applicare le trasformazioni

Il posizionamento dei nodi nello spazio 3D avviene tramite il Transform proprietà su ciascuno 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");

Le trasformazioni seguono il modello standard di ereditarietà padre-figlio: la posizione in spazio mondiale di un figlio è la combinazione della sua trasformazione locale e di tutte le trasformazioni degli antenati fino alla radice.

Cosa è incluso

La libreria è fornita con un insieme mirato di funzionalità progettate attorno al modello di grafo della scena 3D.

Grafo della scena

Il grafo della scena è la spina dorsale dell’API. Ogni file 3D è rappresentato come una struttura ad albero:

Primitive integrate

L’edizione .NET include classi di forme parametriche che possono essere collegate ai nodi direttamente o convertite in Mesh:

• Scatola – scatola allineata agli assi con larghezza, altezza e profondità configurabili.
• Sfera – sfera parametrica con raggio configurabile.
• Cilindro – cilindro parametrico con raggi e altezza configurabili.

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

Materiali

La libreria fornisce diversi tipi di materiale:

• LambertMaterial – materiale classico solo diffuso con componenti di colore ambientale, diffuso, emissivo e riflettente.
• PhongMaterial – estende Lambert con evidenziature speculari e lucentezza.
• PbrMaterial – materiale di rendering basato fisicamente con colore di base, metallicità, rugosità, occlusione e slot di texture.

Utility Matematiche

Il Aspose.ThreeD Il namespace include primitive matematiche essenziali:

• FVector3 – vettore a precisione singola a 3 componenti per posizioni, direzioni e scala. Usato da Transform.Translation e Transform.Scale.
• Vector4 – vettore a precisione singola a 4 componenti per punti di controllo e normali.
• Matrix4 – matrice di trasformazione 4x4.
• Quaternion – rappresentazione di rotazione. Usato da Transform.Rotation.
• BoundingBox – bounding box allineato agli assi per query spaziali.

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

Opzioni di Caricamento e Salvataggio

Ogni formato dispone di classi di opzioni dedicate che consentono di controllare il comportamento di importazione ed esportazione:

Ad esempio, per caricare un file OBJ con inversione delle coordinate e normalizzazione delle normali:

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

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

Formati supportati

La tabella seguente riepiloga i formati che Aspose.3D FOSS per .NET può leggere e scrivere.

Guida alla selezione del formato

Scegliere il formato giusto dipende dal tuo caso d’uso:

• OBJ è ideale quando hai bisogno della massima compatibilità tra gli strumenti 3D. Quasi ogni applicazione di modellazione può leggere e scrivere OBJ. Funziona bene per lo scambio di dati mesh, ma trasporta solo informazioni di base sui materiali tramite i file MTL associati.
• STL è il formato preferito per i flussi di lavoro di stampa 3D. Memorizza geometria triangolata grezza senza materiali o gerarchia della scena, che è esattamente ciò che il software di slicing si aspetta.
• glTF è lo standard moderno per il 3D web e in tempo reale. Supporta materiali PBR, gerarchie di scena complete ed è progettato per una trasmissione efficiente. Usa glTF quando costruisci visualizzatori basati sul web o miri a qualsiasi pipeline di rendering in tempo reale.
• FBX è profondamente integrato nei flussi di lavoro di sviluppo di giochi e creazione di contenuti digitali. Supporta dati di scena ricchi, incluse gerarchie e materiali. Aspose.3D FOSS per .NET supporta FBX importazione ed esportazione sia in modalità ASCII che binaria.
• 3MF è un formato di stampa 3D moderno che supporta metadati ricchi, materiali e scene multi-oggetto in un unico pacchetto basato su ZIP.

Limitazioni note

Scene.Render() è non supportato nella versione FOSS. Chiamare questo metodo genererà un NotImplementedException. La libreria è progettata per l’elaborazione 3D basata su file – caricamento, manipolazione, trasformazione e salvataggio dei modelli – piuttosto che per il rendering in tempo reale su un display.

Open source e licenza

Aspose.3D FOSS per .NET è rilasciato sotto la MIT License. Questo significa che sei libero di:

• Utilizzare la libreria in applicazioni commerciali e proprietarie.
• Modifica il codice sorgente per adattarlo alle tue esigenze.
• Distribuisci la libreria come parte del tuo software.

Non ci sono royalty, limiti di utilizzo né requisiti di attribuzione oltre a quanto specificato dalla licenza MIT.

Il codice sorgente completo è ospitato su GitHub, e i contributi sono benvenuti: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Requisiti di sistema

Iniziare

Ecco le risorse per aiutarti a partire:

• Documentazione – guide complete e walkthrough dell’API sono disponibili su sito di documentazione Aspose.3D.
• Base di conoscenza – articoli pratici passo-passo e suggerimenti per la risoluzione dei problemi in il Aspose.3D KB.
• Riferimento API – riferimento dettagliato a classi e metodi su Aspose.3D Riferimento API.
• Codice sorgente – sfoglia e contribuisci su GitHub.
• NuGet – il pacchetto è pubblicato come Aspose.3D su NuGet.

Casi d’uso comuni

Ecco alcuni scenari pratici in cui Aspose.3D FOSS per .NET si adatta bene:

Pipeline di conversione dei formati

Molti team ricevono asset 3D in un formato ma ne hanno bisogno in un altro. Un team di design potrebbe lavorare in FBX mentre il team web necessita di glTF. La libreria ti consente di creare pipeline di conversione automatizzate:

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

Prima di integrare un asset 3D nella tua applicazione, potresti voler convalidare il suo contenuto — controllare il numero di nodi, verificare la geometria o confermare che gli elementi previsti siano presenti:

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

Assemblaggio della scena

Puoi caricare più modelli e combinarli in un’unica scena:

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

Cosa segue

Nei prossimi post, tratteremo:

• Un’analisi approfondita delle funzionalità chiave dell’API del grafo della scena, dei materiali e delle utility matematiche.
• Una guida pratica per lavorare con ciascun formato 3D supportato — OBJ, STL, glTF, FBX e 3MF — includendo le opzioni di caricamento/salvataggio e i modelli di conversione batch.

Rimanete sintonizzati e sentitevi liberi di esplorare la libreria e condividere il vostro feedback su GitHub.