Einführung von Aspose.3D FOSS für .NET

Wir freuen uns, die Verfügbarkeit von Aspose.3D FOSS for .NET – eine kostenlose, Open-Source-Bibliothek zum Arbeiten mit 3D-Dateiformaten in .NET-Anwendungen. Entwickelt als reine C#-Lösung ohne native Abhängigkeiten, richtet sich die Bibliothek an .NET 10.0 und höher, wodurch sie für ein breites Spektrum an Projekten und Umgebungen zugänglich ist.

Dieser Beitrag führt Sie durch das Angebot der Bibliothek, zeigt, wie Sie starten können, und erklärt, wohin es von hier aus geht.

Was ist Aspose.3D FOSS für .NET?

Aspose.3D FOSS for .NET ist eine leichtgewichtige 3D-Dateiverarbeitungsbibliothek, die veröffentlicht wurde unter der MIT-Lizenz. Sie bietet eine Scene-Graph-API, mit der Sie 3D-Modelle laden, inspizieren, transformieren und in mehreren weit verbreiteten Formaten speichern können. Die Bibliothek ist vollständig in C# geschrieben und erfordert keine externen nativen Binärdateien oder plattformspezifischen Konfigurationen.

Der Quellcode ist auf GitHub verfügbar: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Wichtige Highlights

• Reines C# – kein P/Invoke, keine nativen Bibliotheken, keine Plattformbeschränkungen.
• .NET 10.0+ kompatibel.
• MIT-lizenziert – verwenden Sie es in privaten, kommerziellen oder proprietären Projekten ohne Einschränkungen.
• Szenengraph-Architektur – ein vertrauter Baum von Knoten, Meshes, Kameras und Materialien.
• Unterstützung mehrerer Formate – Lesen und Schreiben von OBJ-, STL-, glTF 2.0-, GLB-, FBX-, Collada- und 3MF-Dateien.

Schnellstart

NuGet-Installation

Fügen Sie das NuGet-Paket zu Ihrem Projekt hinzu:

dotnet add package Aspose.3D --version 26.1.0

Ihre erste Konvertierung

Der einfachste Anwendungsfall besteht darin, eine 3D-Datei in einem Format zu laden und in einem anderen zu speichern. Hier ist eine zweizeilige Konvertierung von OBJ nach STL:

using Aspose.ThreeD;

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

Die Scene Klasse ist der zentrale Einstiegspunkt. Aufrufen scene.Open() mit einem Dateipfad, um ein Modell zu laden, dann aufrufen Save() mit dem Zielpfad. Die Bibliothek ermittelt das Format anhand der Dateierweiterung.

Eine Szene von Grund auf erstellen

Sie können Szenen auch programmgesteuert erstellen:

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

Dies erstellt eine neue Szene, fügt ein Box‑Primitive als Kindknoten unter dem Root‑Knoten hinzu, positioniert es bei den Koordinaten (1, 2, 3) und exportiert das Ergebnis als glTF‑Datei.

Laden mit format­spezifischen Optionen

Wenn Sie eine feinere Kontrolle über den Ladevorgang benötigen, stellt jedes Format eine eigene Optionsklasse bereit. Zum Beispiel das Laden einer STL‑Datei mit expliziten Optionen:

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

Die scene.Open() Methode akzeptiert jede der Ladeoptionstypen: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, oder TmfLoadOptions.

Durchlaufen des Szenengraphen

Sobald eine Szene geladen ist, können Sie den Knotbaum durchlaufen, um deren Inhalt zu inspizieren oder zu ändern:

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

Dieses Muster ist nützlich zum Debuggen, zum Erstellen von Berichten über den Modellinhalt oder zum selektiven Ändern von Teilen einer Szene vor dem erneuten Export.

Anwenden von Transformationen

Das Positionieren von Knoten im 3D-Raum erfolgt über die Transform Eigenschaft jedes 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");

Transformationen folgen dem üblichen Eltern‑Kind‑Vererbungsmodell: Die Weltposition eines Kindes ist die Kombination seiner lokalen Transformation und aller Transformations‑Vorfahren bis zum Root.

Was enthalten ist

Die Bibliothek wird mit einem fokussierten Funktionsumfang geliefert, der um das 3D‑Szenengraph‑Modell herum konzipiert ist.

Szenengraph

Der Szenengraph ist das Rückgrat der API. Jede 3D-Datei wird als Baumstruktur dargestellt:

Eingebaute Primitive

Die .NET-Edition enthält parametrische Formklassen, die direkt an Knoten angehängt oder konvertiert werden können zu Mesh:

• Box – achsenorientierter Quader mit konfigurierbarer Breite, Höhe und Tiefe.
• Sphere – parametrische Kugel mit konfigurierbarem Radius.
• Cylinder – parametrischer Zylinder mit konfigurierbaren Radien und Höhe.

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

Materialien

Die Bibliothek bietet mehrere Materialtypen:

• LambertMaterial – klassisches reines Diffusmaterial mit Umgebungs-, Diffus-, Emissions- und Reflexionsfarbkomponenten.
• PhongMaterial – erweitert Lambert um spiegelnde Glanzlichter und Glanz.
• PbrMaterial – physikalisch basiertes Rendering-Material mit Grundfarbe, Metallisch, Rauheit, Okklusion und Textur‑Slots.

Mathematische Hilfsfunktionen

Der Aspose.ThreeD Namespace enthält wesentliche mathematische Primitive:

• FVector3 – Single-Precision 3-Komponenten-Vektor für Positionen, Richtungen und Skalierung. Verwendet von Transform.Translation und Transform.Scale.
• Vector4 – Single-Precision 4-Komponenten-Vektor für Kontrollpunkte und Normalen.
• Matrix4 – 4x4 Transformationsmatrix.
• Quaternion – Rotationsdarstellung. Verwendet von Transform.Rotation.
• BoundingBox – achsenorientierte Begrenzungsbox für räumliche Abfragen.

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

Lade‑ und Speicheroptionen

Jedes Format hat eigene Optionsklassen, die es Ihnen ermöglichen, das Import‑ und Exportverhalten zu steuern:

Zum Beispiel, um eine OBJ‑Datei mit Koordinatenumkehr und Normalen‑Normalisierung zu laden:

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

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

Unterstützte Formate

Die folgende Tabelle fasst die Formate zusammen, die Aspose.3D FOSS für .NET lesen und schreiben kann.

Leitfaden zur Formatwahl

Die Wahl des richtigen Formats hängt von Ihrem Anwendungsfall ab:

• OBJ ist ideal, wenn Sie maximale Kompatibilität über 3D‑Werkzeuge hinweg benötigen. Praktisch jede Modellierungsanwendung kann OBJ lesen und schreiben. Es eignet sich gut für den Austausch von Mesh‑Daten, enthält jedoch nur grundlegende Materialinformationen über Begleit‑MTL‑Dateien.
• STL ist das bevorzugte Format für 3D‑Druck‑Workflows. Es speichert rohe triangulierte Geometrie ohne Materialien oder Szenenhierarchie, genau das, was Slicer‑Software erwartet.
• glTF ist der moderne Standard für Web‑ und Echtzeit‑3D. Es unterstützt PBR‑Materialien, vollständige Szenenhierarchien und ist für effiziente Übertragung konzipiert. Verwenden Sie glTF beim Aufbau webbasierter Viewer oder wenn Sie eine Echtzeit‑Rendering‑Pipeline anvisieren.
• FBX ist tief in Spielentwicklung und Workflows für digitale Inhaltserstellung integriert. Es unterstützt umfangreiche Szenendaten einschließlich Hierarchien und Materialien. Aspose.3D FOSS für .NET unterstützt FBX Import und Export sowohl im ASCII‑ als auch im Binärmodus.
• 3MF ist ein modernes 3D‑Druck‑Format, das umfangreiche Metadaten, Materialien und Mehr‑Objekt‑Szenen in einem einzigen ZIP-basierten Paket unterstützt.

Bekannte Einschränkungen

Scene.Render() ist nicht unterstützt in der FOSS‑Edition. Der Aufruf dieser Methode löst einen NotImplementedException. Die Bibliothek ist für dateibasierte 3D-Verarbeitung konzipiert – Laden, Manipulieren, Transformieren und Speichern von Modellen – und nicht für Echtzeit-Rendering auf einem Display.

Open Source und Lizenzierung

Aspose.3D FOSS für .NET wird veröffentlicht unter der MIT-Lizenz. Das bedeutet, Sie sind frei zu:

• Die Bibliothek in kommerziellen und proprietären Anwendungen verwenden.
• Passen Sie den Quellcode an Ihre Bedürfnisse an.
• Verteilen Sie die Bibliothek als Teil Ihrer eigenen Software.

Es gibt keine Lizenzgebühren, keine Nutzungslimits und keine Namensnennungsanforderungen über das hinaus, was die MIT-Lizenz vorsieht.

Der vollständige Quellcode ist auf GitHub gehostet, und Beiträge sind willkommen: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Systemanforderungen

Erste Schritte

Hier sind die Ressourcen, die Ihnen den Einstieg erleichtern:

• Dokumentation – umfassende Leitfäden und API-Durchläufe sind auf dem Aspose.3D Dokumentationsseite.
• Wissensdatenbank – praktische Anleitungen und Fehlerbehebungstipps in der Aspose.3D KB.
• API-Referenz – detaillierte Klassen- und Methodenreferenz auf der Aspose.3D API-Referenz.
• Quellcode – durchsuchen und beitragen auf GitHub.
• NuGet – das Paket wird veröffentlicht als Aspose.3D auf NuGet.

Gängige Anwendungsfälle

Hier sind einige praktische Szenarien, in denen Aspose.3D FOSS für .NET gut passt:

Formatkonvertierungs-Pipelines

Viele Teams erhalten 3D‑Assets in einem Format, benötigen sie jedoch in einem anderen. Ein Designteam arbeitet möglicherweise mit FBX, während das Webteam glTF benötigt. Die Bibliothek ermöglicht es Ihnen, automatisierte Konvertierungspipelines zu erstellen:

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

Bevor Sie ein 3D-Asset in Ihre Anwendung integrieren, möchten Sie möglicherweise dessen Inhalt validieren – die Knotenzahl prüfen, die Geometrie verifizieren oder bestätigen, dass die erwarteten Elemente vorhanden sind:

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

Szenenassemblage

Sie können mehrere Modelle laden und sie zu einer einzigen Szene kombinieren:

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

Was kommt als Nächstes

In den kommenden Beiträgen behandeln wir:

• Ein tiefer Einblick in die wichtigsten Funktionen der Scene-Graph-API, Materialien und mathematischen Hilfsprogrammen.
• Ein praktischer Leitfaden zur Arbeit mit jedem unterstützten 3D-Format – OBJ, STL, glTF, FBX und 3MF – einschließlich Lade-/Speicheroptionen und Mustern für die Batch-Konvertierung.

Bleiben Sie dran und fühlen Sie sich frei, die Bibliothek zu erkunden und Ihr Feedback auf GitHub zu teilen.