Introducerar Aspose.3D FOSS för .NET

Vi är glada att meddela tillgängligheten av Aspose.3D FOSS for .NET – ett gratis, öppen källkod‑bibliotek för att arbeta med 3D‑filformat i .NET-applikationer. Byggt som en ren C#‑lösning utan inhemska beroenden, riktar sig biblioteket mot .NET 10.0 och senare, vilket gör det tillgängligt för ett brett spektrum av projekt och miljöer.

Detta inlägg går igenom vad biblioteket erbjuder, hur du kommer igång och vart du kan gå härifrån.

Vad är Aspose.3D FOSS för .NET?

Aspose.3D FOSS for .NET är ett lättviktigt 3D‑filbehandlingsbibliotek publicerat under den MIT-licens. Den tillhandahåller ett scene‑graph‑API som låter dig läsa in, inspektera, transformera och spara 3D‑modeller i flera allmänt använda format. Biblioteket är helt skrivet i C# och kräver inga externa inhemska binärer eller plattforms‑specifika konfigurationer.

Källkoden finns tillgänglig på GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Nyckelfunktioner

• Ren C# – ingen P/Invoke, inga inhemska bibliotek, inga plattformsrestriktioner.
• .NET 10.0+ kompatibel.
• MIT-licensierad – använd den i personliga, kommersiella eller proprietära projekt utan restriktioner.
• Scene‑graph‑arkitektur – ett välbekant träd av noder, meshar, kameror och material.
• Stöd för flera format – läs och skriv OBJ, STL, glTF 2.0, GLB, FBX, Collada och 3MF-filer.

Snabbstart

NuGet‑installation

Lägg till NuGet‑paketet i ditt projekt:

dotnet add package Aspose.3D.Converter --version 1.0.0

Din första konvertering

Det enklaste användningsfallet är att läsa in en 3D-fil i ett format och spara den i ett annat. Här är en två‑raders konvertering från OBJ till STL:

using Aspose.ThreeD;

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

Den Scene klass är den centrala ingångspunkten. Anropa scene.Open() med en filsökväg för att läsa in en modell, sedan anropa Save() med målvägen. Biblioteket härleder formatet från filändelsen.

Bygga en scen från grunden

Du kan också konstruera scener programatiskt:

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

Detta skapar en ny scen, lägger till en box‑primitiv som ett barnnod under roten, placerar den på koordinaterna (1, 2, 3) och exporterar resultatet som en glTF‑fil.

Laddning med format‑specifika alternativ

När du behöver finare kontroll över laddningsprocessen erbjuder varje format en dedikerad alternativklass. Till exempel, att ladda en STL‑fil med explicita alternativ:

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

Det scene.Open() metoden accepterar någon av laddningsalternativtyperna: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, eller TmfLoadOptions.

Traversera scen‑grafen

När en scen har laddats kan du gå igenom nodträdet för att inspektera eller modifiera dess innehåll:

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

Detta mönster är användbart för felsökning, generering av rapporter om modellens innehåll, eller för att selektivt modifiera delar av en scen innan den exporteras igen.

Applicera transformationer

Positionering av noder i 3D-rymden görs via Transform egenskap på varje 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");

Transformationer följer den standardiserade föräldra‑barn‑arvmodellen: ett barns position i världsrummet är kombinationen av dess lokala transformation och alla förfäders transformationer upp till roten.

Vad som ingår

Biblioteket levereras med en fokuserad uppsättning funktioner utformade kring 3D-scengrafmodellen.

Scengraf

Scengrafen är ryggraden i API:et. Varje 3D-fil representeras som en trädstruktur:

Inbyggda primitivformer

Editionen .NET inkluderar parametriska formklasser som kan fästas direkt på noder eller konverteras till Mesh:

• Låda – axeljusterad låda med konfigurerbar bredd, höjd och djup.
• Sfär – parametrisk sfär med konfigurerbar radie.
• Cylinder – parametrisk cylinder med konfigurerbara radier och höjd.

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

Material

Biblioteket tillhandahåller flera materialtyper:

• LambertMaterial – klassiskt material med endast diffus reflektion med ambient, diffus, emissiv och reflekterande färgkomponenter.
• PhongMaterial – utökar Lambert med spekulära högdagrar och glans.
• PbrMaterial – fysiskt baserat renderingsmaterial med basfärg, metallisk, rughet, okklusion och texturplatser.

Matematikverktyg

Den Aspose.ThreeD namnutrymmet innehåller väsentliga matematiska primitiv.:

• FVector3 – enkelprecisions 3-komponentsvektor för positioner, riktningar och skala. Används av Transform.Translation och Transform.Scale.
• Vector4 – enkelprecisions 4-komponentsvektor för kontrollpunkter och normaler.
• Matrix4 – 4x4 transformationsmatris.
• Quaternion – rotationsrepresentation. Används av Transform.Rotation.
• BoundingBox – axeljusterad avgränsningsbox för rumsliga frågor.

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

Läs- och sparaalternativ

Varje format har dedikerade alternativklasser som låter dig styra import- och exportbeteende:

Till exempel, för att läsa in en OBJ-fil med koordinatvändning och normalnormalisering:

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

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

Stödda format

Följande tabell sammanfattar de format som Aspose.3D FOSS för .NET kan läsa och skriva.

Guide för formatval

Att välja rätt format beror på ditt användningsfall:

• OBJ är ideal när du behöver maximal kompatibilitet över 3D-verktyg. Nästan alla modelleringsprogram kan läsa och skriva OBJ. Det fungerar bra för utbyte av mesh-data men innehåller endast grundläggande materialinformation via medföljande MTL-filer.
• STL är det föredragna formatet för 3D-utskriftsarbetsflöden. Det lagrar rå triangulerad geometri utan material eller scenhierarki, vilket är exakt vad slicer‑programvara förväntar sig.
• glTF är den moderna standarden för webb- och realtids‑3D. Det stödjer PBR‑material, fullständiga scenhierarkier och är designat för effektiv överföring. Använd glTF när du bygger webbaserade visare eller riktar dig mot någon realtidsrenderingspipeline.
• FBX är djupt integrerat i spelutveckling och arbetsflöden för digitalt innehållsskapande. Det stödjer rik sceninformation inklusive hierarkier och material. Aspose.3D FOSS för .NET stödjer FBX import och export i både ASCII- och binära lägen.
• 3MF är ett modernt 3D-utskriftsformat som stödjer rik metadata, material och flerdelscener i ett enda ZIP-baserat paket.

Kända begränsningar

Scene.Render() är stöds inte i FOSS-utgåvan. Att anropa den här metoden kommer att kasta ett NotImplementedException. Biblioteket är utformat för filbaserad 3D-behandling – inläsning, manipulering, transformation och sparande av modeller – snarare än realtidsrendering till en skärm.

Öppen källkod och licensiering

Aspose.3D FOSS för .NET släpps under MIT License. Detta betyder att du är fri att:

• Använd biblioteket i kommersiella och proprietära applikationer.
• Modifiera källkoden för att passa dina behov.
• Distribuera biblioteket som en del av din egen programvara.

Det finns inga royaltyavgifter, inga användningsgränser och inga krav på attribution utöver vad MIT-licensen specificerar.

Den fullständiga källkoden finns på GitHub, och bidrag är välkomna: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Systemkrav

Komma igång

Här är resurserna som hjälper dig att komma igång:

• Dokumentation – omfattande guider och API-genomgångar finns tillgängliga på Aspose.3D dokumentationssida.
• Kunskapsbas – praktiska hur-man-gör-artiklar och felsökningstips i Aspose.3D KB.
• API-referens – detaljerad klass- och metodreferens på Aspose.3D API-referens.
• Källkod – bläddra och bidra på GitHub.
• NuGet – paketet publiceras som Aspose.3D.Converter på NuGet.

Vanliga användningsfall

Här är några praktiska scenarier där Aspose.3D FOSS för .NET passar bra:

Formatkonverteringspipelines

Många team får 3D‑tillgångar i ett format men behöver dem i ett annat. Ett designteam kan arbeta i FBX medan webbteamet behöver glTF. Biblioteket låter dig bygga automatiserade konverteringspipelines:

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

Innan du integrerar en 3D‑tillgång i din applikation kan du vilja validera dess innehåll – kontrollera nodantal, verifiera geometri eller bekräfta att förväntade element finns:

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

Sammansättning av scen

Du kan ladda flera modeller och kombinera dem till en enda scen:

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

Vad blir nästa

I kommande inlägg kommer vi att gå igenom:

• En djupdykning i nyckelfunktionerna i scene‑graph‑API:et, material och matematiska verktyg.
• En praktisk guide för att arbeta med varje stödd 3D‑format – OBJ, STL, glTF, FBX och 3MF – inklusive laddnings‑/sparalternativ och batch‑konverteringsmönster.

Håll utkik, och känn dig fri att utforska biblioteket och dela din feedback på GitHub.