Introducerer Aspose.3D FOSS for .NET

Vi er glade for at kunne annoncere tilgængeligheden af Aspose.3D FOSS for .NET – et gratis, open-source bibliotek til at arbejde med 3D‑filformater i .NET-applikationer. Bygget som en ren C#‑løsning uden native afhængigheder, biblioteket målretter .NET 10.0 og senere, hvilket gør det tilgængeligt for en bred vifte af projekter og miljøer.

Dette indlæg gennemgår, hvad biblioteket tilbyder, hvordan du kommer i gang, og hvor du kan gå videre derfra.

Hvad er Aspose.3D FOSS for .NET?

Aspose.3D FOSS for .NET er et letvægts 3D‑filbehandlingsbibliotek udgivet under den MIT license. Den leverer et scene‑graph‑API, der lader dig indlæse, inspicere, transformere og gemme 3D‑modeller på tværs af flere udbredte formater. Biblioteket er fuldstændigt skrevet i C# og kræver ingen eksterne native binære filer eller platformspecifikke konfigurationer.

Kildekoden er tilgængelig på GitHub: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Nøglefunktioner

• Ren C# – ingen P/Invoke, ingen native biblioteker, ingen platformbegrænsninger.
• .NET 10.0+ kompatibel.
• MIT licensed – brug det i personlige, kommercielle eller proprietære projekter uden restriktioner.
• Scene‑graph‑arkitektur – et velkendt træ af noder, mesh‑objekter, kameraer og materialer.
• Understøttelse af flere formater – læse og skrive OBJ, STL, glTF 2.0, GLB, FBX, Collada og 3MF-filer.

Hurtig start

NuGet-installation

Tilføj NuGet-pakken til dit projekt:

dotnet add package Aspose.3D --version 26.1.0

Din første konvertering

Det simpleste brugstilfælde er at indlæse en 3D-fil i ét format og gemme den i et andet. Her er en to‑linjers konvertering fra OBJ til STL:

using Aspose.ThreeD;

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

Den Scene klassen er det centrale indgangspunkt. Kald scene.Open() med en filsti for at indlæse en model, derefter kald Save() med målstien. Biblioteket udleder formatet ud fra filendelsen.

Opbygning af en scene fra bunden

Du kan også konstruere scener programmatisk:

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

Dette opretter en ny scene, tilføjer en boks‑primitive som et underordnet node under roden, placerer den på koordinaterne (1, 2, 3) og eksporterer resultatet som en glTF‑fil.

Indlæsning med format‑specifikke indstillinger

Når du har brug for finere kontrol over indlæsningsprocessen, tilbyder hvert format en dedikeret indstillingsklasse. For eksempel, indlæsning af en STL‑fil med eksplicitte indstillinger:

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

Den scene.Open() metoden accepterer enhver af indlæsningsindstillings-typerne: ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, eller TmfLoadOptions.

Gennemløb af scene‑grafen

Når en scene er indlæst, kan du gå gennem nodetræet for at inspicere eller ændre dets indhold:

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

Dette mønster er nyttigt til fejlfinding, generering af rapporter om modellens indhold eller selektiv ændring af dele af en scene inden geneksport.

Anvendelse af transformationer

Placering af noder i 3D-rum udføres gennem Transform egenskab på hver 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ølger den standard forælder‑barn‑arvningsmodel: et barns position i verdensrum er kombinationen af dets lokale transformation og alle forældrenes transformationer op til roden.

Hvad der er inkluderet

Biblioteket leveres med et fokuseret sæt af funktioner designet omkring 3D‑scene‑grafmodellen.

Scene‑graf

Scenegrafen er rygraden i API’en. Hver 3D-fil repræsenteres som en træstruktur:

Indbyggede primitive

Den .NET udgave inkluderer parametriske formklasser, der kan knyttes direkte til noder eller konverteres til Mesh:

• Boks – aksejusteret boks med konfigurerbar bredde, højde og dybde.
• Kugle – parametrisk kugle med konfigurerbar radius.
• Cylinder – parametrisk cylinder med konfigurerbare radier og højde.

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

Materialer

Biblioteket leverer flere materialetyper:

• LambertMaterial – klassisk kun-diffus materiale med omgivende, diffus, emissiv og reflekterende farvekomponenter.
• PhongMaterial – udvider Lambert med speculære højlys og glans.
• PbrMaterial – fysisk baseret renderingsmateriale med grundfarve, metallisk, ruhed, okklusion og teksturpladser.

Matematikværktøjer

Den Aspose.ThreeD navnerum indeholder essentielle matematiske primitive:

• FVector3 – enkeltpræcisions 3-komponent vektor til positioner, retninger og skala. Bruges af Transform.Translation og Transform.Scale.
• Vector4 – enkeltpræcisions 4-komponent vektor til kontrolpunkter og normaler.
• Matrix4 – 4x4 transformationsmatrix.
• Quaternion – rotationsrepræsentation. Bruges af Transform.Rotation.
• BoundingBox – aksejusteret begrænsningsboks til rumlige forespørgsler.

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

Indlæsnings- og gemmeindstillinger

Hvert format har dedikerede optionsklasser, der giver dig mulighed for at styre import- og eksportadfærd:

For eksempel, for at indlæse en OBJ-fil med koordinat-ombytning og normalisering af normaler:

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

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

Understøttede formater

Følgende tabel opsummerer de formater, som Aspose.3D FOSS for .NET kan læse og skrive.

Guide til valg af format

Valg af det rigtige format afhænger af din anvendelse:

• OBJ er ideel, når du har brug for maksimal kompatibilitet på tværs af 3D-værktøjer. Næsten alle modelleringsprogrammer kan læse og skrive OBJ. Den fungerer godt til udveksling af mesh-data, men indeholder kun grundlæggende materialinformation via tilhørende MTL-filer.
• STL er det foretrukne format til 3D-printarbejdsprocesser. Det gemmer rå trianguleret geometri uden materialer eller scenehierarki, hvilket er præcis, hvad slicer‑software forventer.
• glTF er den moderne standard for web- og realtids‑3D. Den understøtter PBR-materialer, komplette scenehierarkier og er designet til effektiv transmission. Brug glTF, når du bygger webbaserede visningsprogrammer eller målretter enhver realtids‑renderingspipeline.
• FBX er dybt integreret i spiludvikling og arbejdsgange for digitalt indhold. Den understøtter rige scenedata inklusive hierarkier og materialer. Aspose.3D FOSS for .NET understøtter FBX import og eksport i både ASCII- og binære tilstande.
• 3MF er et moderne 3D-printformat, der understøtter rige metadata, materialer og flerdels-scener i en enkelt ZIP-baseret pakke.

Kendte begrænsninger

Scene.Render() er understøttes ikke i FOSS-udgaven. At kalde denne metode vil kaste en NotImplementedException. Biblioteket er designet til filbaseret 3D-behandling – indlæsning, manipulation, transformation og lagring af modeller – i stedet for realtidsrendering til en skærm.

Open source og licensering

Aspose.3D FOSS for .NET er udgivet under den MIT-licens. Dette betyder, at du er fri til at:

• Bruge biblioteket i kommercielle og proprietære applikationer.
• Modificér kildekoden, så den passer til dine behov.
• Distribuer biblioteket som en del af din egen software.

Der er ingen royaltygebyrer, ingen brugsbegrænsninger og ingen krav om kreditering ud over, hvad MIT-licensen specificerer.

Den fulde kildekode er hostet på GitHub, og bidrag er velkomne: https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Systemkrav

Kom i gang

Her er ressourcerne, der hjælper dig i gang:

• Dokumentation – omfattende vejledninger og API-gennemgange er tilgængelige på den Aspose.3D dokumentationsside.
• Vidensbase – praktiske how-to-artikler og fejlfindingstips i Aspose.3D KB.
• API-reference – detaljeret klasse- og metode-referencer på Aspose.3D API-reference.
• Kildekode – gennemse og bidrage på GitHub.
• NuGet – pakken udgives som Aspose.3D på NuGet.

Almindelige anvendelsestilfælde

Her er nogle praktiske scenarier, hvor Aspose.3D FOSS for .NET passer godt:

Formatkonverterings‑pipelines

Mange teams modtager 3D‑assets i ét format, men har brug for dem i et andet. Et designteam kan arbejde i FBX, mens webteamet har brug for glTF. Biblioteket giver dig mulighed for at bygge automatiserede konverterings‑pipelines:

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

Før du integrerer en 3D‑ressource i din applikation, vil du måske validere dens indhold – kontrollere antallet af noder, verificere geometrien eller bekræfte, at de forventede elementer er til stede:

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

Scene-samling

Du kan indlæse flere modeller og kombinere dem til en enkelt scene:

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

Hvad er næste

I kommende indlæg vil vi dække:

• En dybdegående gennemgang af de vigtigste funktioner i scene‑graph API’en, materialer og matematik‑værktøjer.
• En praktisk guide til at arbejde med hvert understøttet 3D-format – OBJ, STL, glTF, FBX og 3MF – inklusive indlæsnings-/gemme‑muligheder og batch‑konverteringsmønstre.

Hold dig opdateret, og føl dig fri til at udforske biblioteket og dele din feedback på GitHub.