Introductie van Aspose.3D FOSS voor .NET

We zijn verheugd de beschikbaarheid aan te kondigen van Aspose.3D FOSS for .NET – een gratis, open-source bibliotheek voor het werken met 3D-bestandsformaten in .NET-toepassingen. Gebouwd als een pure C#-oplossing zonder native afhankelijkheden, richt de bibliotheek zich op .NET 10.0 en later, waardoor hij toegankelijk is voor een breed scala aan projecten en omgevingen.

Dit bericht loopt door wat de bibliotheek biedt, hoe je kunt beginnen, en waar je vanaf hier naartoe kunt gaan.

Wat is Aspose.3D FOSS voor .NET?

Aspose.3D FOSS for .NET is een lichtgewicht 3D-bestandsverwerkingsbibliotheek gepubliceerd onder de MIT-licentie. Het biedt een scene-graph API waarmee je 3D-modellen kunt laden, inspecteren, transformeren en opslaan in verschillende veelgebruikte formaten. De bibliotheek is volledig geschreven in C# en vereist geen externe native binaries of platformspecifieke configuraties.

De broncode is beschikbaar op GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Belangrijkste hoogtepunten

• Pure C# – geen P/Invoke, geen native libraries, geen platformrestricties.
• .NET 10.0+ compatibel.
• gelicentieerd onder MIT – gebruik het in persoonlijke, commerciële of propriëtaire projecten zonder beperkingen.
• Scene-graph architectuur – een bekende boom van nodes, meshes, camera’s en materialen.
• Ondersteuning voor meerdere formaten – lees en schrijf OBJ, STL, glTF 2.0, GLB, FBX, Collada en 3MF-bestanden.

Snelle start

NuGet-installatie

Voeg het NuGet‑pakket toe aan je project:

dotnet add package Aspose.3D --version 26.1.0

Je eerste conversie

Het eenvoudigste gebruiksscenario is het laden van een 3D‑bestand in één formaat en het opslaan in een ander. Hier is een conversie in twee regels van OBJ naar STL:

using Aspose.ThreeD;

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

De Scene class is het centrale toegangspunt. Roep scene.Open() met een bestandspad om een model te laden, roep dan Save() met het doelpad. De bibliotheek leidt het formaat af van de bestandsextensie.

Een scene vanaf nul bouwen

Je kunt ook scenes programmatisch construeren:

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

Dit maakt een nieuwe scene aan, voegt een box‑primitive toe als kindknooppunt onder de root, plaatst deze op coördinaten (1, 2, 3) en exporteert het resultaat als een glTF‑bestand.

Laden met formaat‑specifieke opties

Wanneer je fijnere controle over het laadproces nodig hebt, biedt elk formaat een eigen opties‑klasse. Bijvoorbeeld, het laden van een STL‑bestand met expliciete opties:

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

De scene.Open() methode accepteert een van de laadoptietypen: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, of TmfLoadOptions.

Doorlopen van de scene‑grafiek

Zodra een scene is geladen, kun je de knoopboom doorlopen om de inhoud te inspecteren of te wijzigen:

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

Dit patroon is nuttig voor debugging, het genereren van rapporten over de modelinhoud, of het selectief aanpassen van delen van een scene vóór het opnieuw exporteren.

Transformaties toepassen

Het positioneren van knooppunten in 3D-ruimte gebeurt via de Transform eigenschap op elke 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");

Transformaties volgen het standaard ouder‑kind‑erfenismodel: de wereld‑ruimte positie van een kind is de combinatie van zijn lokale transformatie en alle transformaties van de voorouders tot aan de root.

Wat er inbegrepen is

De bibliotheek wordt geleverd met een gerichte set mogelijkheden die zijn ontworpen rond het 3D scene-graph model.

Scenegraph

De scenegraph is de ruggengraat van de API. Elk 3D‑bestand wordt weergegeven als een boomstructuur:

Ingebouwde primitieve vormen

De .NET editie bevat parametrische vormklassen die direct aan knooppunten kunnen worden gekoppeld of geconverteerd kunnen worden naar Mesh:

• Doos – asgeoriënteerde doos met configureerbare breedte, hoogte en diepte.
• Bol – parametrische bol met configureerbare straal.
• Cilinder – parametrische cilinder met configureerbare stralen en hoogte.

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

Materialen

De bibliotheek biedt meerdere materiaaltypes:

• LambertMaterial – klassiek alleen-diffuus materiaal met omgevings-, diffuse-, emissieve- en reflecterende kleurcomponenten.
• PhongMaterial – breidt Lambert uit met speculaire highlights en glans.
• PbrMaterial – fysiek gebaseerd rendermateriaal met basiskleur, metallic, ruwheid, occlusie en textuur‑slots.

Wiskundige hulpprogramma’s

De Aspose.ThreeD namespace bevat essentiële wiskundige primitieve types:

• FVector3 – enkelprecisie 3-component vector voor posities, richtingen en schaal. Gebruikt door Transform.Translation en Transform.Scale.
• Vector4 – enkelprecisie 4-component vector voor controlepunten en normaalvectoren.
• Matrix4 – 4x4 transformatie‑matrix.
• Quaternion – rotatie‑representatie. Gebruikt door Transform.Rotation.
• BoundingBox – axis-aligned bounding box voor ruimtelijke query’s.

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

Laad- en opslaanopties

Elk formaat heeft toegewijde optieklassen die je in staat stellen het import- en exportgedrag te beheersen:

Bijvoorbeeld, om een OBJ‑bestand te laden met coördinatenomkering en normalisatie van normaalvectoren:

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

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

Ondersteunde formaten

De volgende tabel geeft een overzicht van de formaten die Aspose.3D FOSS voor .NET kan lezen en schrijven.

Gids voor formaatselectie

Het kiezen van het juiste formaat hangt af van je gebruikssituatie:

• OBJ is ideaal wanneer je maximale compatibiliteit over 3D‑tools nodig hebt. Bijna elke modelleringsapplicatie kan OBJ lezen en schrijven. Het werkt goed voor mesh‑gegevensuitwisseling, maar bevat alleen basismateriaalinformatie via bijbehorende MTL‑bestanden.
• STL is het formaat van keuze voor 3D‑printworkflows. Het slaat ruwe getrianguleerde geometrie op zonder materialen of scène‑hiërarchie, precies wat slicersoftware verwacht.
• glTF is de moderne standaard voor web‑ en realtime‑3D. Het ondersteunt PBR‑materialen, volledige scène‑hiërarchieën, en is ontworpen voor efficiënte transmissie. Gebruik glTF bij het bouwen van web‑gebaseerde viewers of bij het richten op elke realtime‑renderpipeline.
• FBX is diep geïntegreerd in game‑ontwikkeling en workflows voor digitale contentcreatie. Het ondersteunt rijke scenedata, inclusief hiërarchieën en materialen. Aspose.3D FOSS voor .NET ondersteunt FBX importeren en exporteren in zowel ASCII- als binaire modi.
• 3MF is een modern 3D‑printformaat dat rijke metadata, materialen en multi‑object‑scènes ondersteunt in één ZIP-gebaseerd pakket.

Bekende beperkingen

Scene.Render() is niet ondersteund in de FOSS-editie. Het aanroepen van deze methode zal een NotImplementedException. De bibliotheek is ontworpen voor bestandsgebaseerde 3D-verwerking – laden, manipuleren, transformeren en opslaan van modellen – in plaats van real-time rendering naar een scherm.

Open source en licensering

Aspose.3D FOSS voor .NET is uitgebracht onder de MIT-licentie. Dit betekent dat u vrij bent om:

• De bibliotheek gebruiken in commerciële en propriëtaire toepassingen.
• De broncode aanpassen aan je behoeften.
• De bibliotheek distribueren als onderdeel van je eigen software.

Er zijn geen royaltykosten, geen gebruikslimieten en geen naamsvermeldingseisen, behalve wat de MIT-licentie specificeert.

De volledige broncode wordt gehost op GitHub, en bijdragen zijn welkom: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Systeemvereisten

Aan de slag

Hier zijn de bronnen om je op weg te helpen:

• Documentatie – uitgebreide handleidingen en API-walkthroughs zijn beschikbaar op de Aspose.3D documentatiesite.
• Kennisbank – praktische how-to artikelen en probleemoplossingstips in de Aspose.3D KB.
• API-referentie – gedetailleerde klasse- en methodereferentie bij de Aspose.3D API-referentie.
• Broncode – bladeren en bijdragen op GitHub.
• NuGet – het pakket wordt gepubliceerd als Aspose.3D op NuGet.

Veelvoorkomende gebruikssituaties

Hier zijn enkele praktische scenario’s waarin Aspose.3D FOSS voor .NET goed past:

Formaatconversiepijplijnen

Veel teams ontvangen 3D‑assets in één formaat, maar hebben ze in een ander nodig. Een ontwerpteam werkt misschien met FBX, terwijl het webteam glTF nodig heeft. De bibliotheek stelt je in staat geautomatiseerde conversiepijplijnen te bouwen:

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

Voordat je een 3D‑asset in je applicatie integreert, wil je mogelijk de inhoud valideren — het controleren van het aantal knooppunten, het verifiëren van de geometrie, of bevestigen dat verwachte elementen aanwezig zijn:

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

Scène‑assemblage

Je kunt meerdere modellen laden en ze combineren tot één enkele scène:

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

Wat volgt

In komende berichten behandelen we:

• Een diepgaande duik in de belangrijkste functies van de scene‑graph‑API, materialen en wiskundige hulpprogramma’s.
• Een praktische gids voor het werken met elk ondersteund 3D‑formaat — OBJ, STL, glTF, FBX en 3MF — inclusief laad-/opslaoptopties en batch‑conversiepatronen.

Blijf op de hoogte en voel je vrij om de bibliotheek te verkennen en je feedback te delen op GitHub.