Principales fonctionnalités de Aspose.3D FOSS pour .NET

Dans le article d’introduction, nous avons couvert ce que Aspose.3D FOSS pour .NET est et comment commencer. Cet article approfondit les fonctionnalités clés qui composent la bibliothèque, avec des exemples de code pour chaque domaine.

Tous les exemples supposent la directive using suivante :

using Aspose.ThreeD;
using Aspose.ThreeD.Entities;
using Aspose.ThreeD.Shading;

Et le package NuGet :

dotnet add package Aspose.3D --version 26.1.0

Le graphe de scène

Le graphe de scène est la structure de données principale. Un Scene contient un RootNode, et chaque Node peut avoir des nœuds enfants et un Entity (comme un Mesh ou Camera).

Création et navigation des nœuds

var scene = new Scene();

// Create a hierarchy
var parent = scene.RootNode.CreateChildNode("Parent");
var child1 = parent.CreateChildNode("Child1");
var child2 = parent.CreateChildNode("Child2");

// Navigate the tree
Console.WriteLine("Root children: " + scene.RootNode.ChildNodes.Count);
Console.WriteLine("Parent children: " + parent.ChildNodes.Count);

Attacher des entités aux nœuds

Les entités sont le contenu visuel de la scène – maillages, caméras et lumières. Attachez-les en utilisant CreateChildNode:

var scene = new Scene();

// Create a box primitive and attach it to the scene
var box = new Box(2, 2, 2);
var boxNode = scene.RootNode.CreateChildNode("BoxNode", box);

// Create a sphere primitive
var sphere = new Sphere(1);
var sphereNode = scene.RootNode.CreateChildNode("SphereNode", sphere);

scene.Save("primitives.gltf");

Primitives intégrées

L’édition .NET comprend des classes de formes paramétriques qui génèrent la géométrie sans construction manuelle de sommets :

Ces primitives peuvent être attachées directement aux nœuds ou converties en un Mesh via ToMesh():

var cylinder = new Cylinder(1, 1, 2);
var mesh = cylinder.ToMesh();

Console.WriteLine("Vertices: " + mesh.ControlPoints.Count);
Console.WriteLine("Polygons: " + mesh.PolygonCount);

Construction de maillage

Si vous avez besoin d’un contrôle total, construisez des maillages à partir de zéro en utilisant des points de contrôle et des définitions de polygones :

var mesh = new Mesh();

// Add vertex positions
mesh.ControlPoints.Add(new Vector4(0, 0, 0, 1.0f));
mesh.ControlPoints.Add(new Vector4(1, 0, 0, 1.0f));
mesh.ControlPoints.Add(new Vector4(0.5f, 1, 0, 1.0f));

// Define a triangle face
mesh.CreatePolygon(0, 1, 2);

// Attach to a scene
var scene = new Scene();
scene.RootNode.CreateChildNode("triangle", mesh);
scene.Save("triangle.stl");

Les points de contrôle utilisent Vector4 avec le w composant défini sur 1.0f pour des positions cartésiennes standard. Les polygones sont définis en passant les indices des points de contrôle à CreatePolygon().

Transformations

Chaque Node possède un Transform propriété qui contrôle sa position locale, sa rotation et son échelle :

var scene = new Scene();

var node = scene.RootNode.CreateChildNode("Moved");
node.Transform.Translation = new FVector3(5, 0, 0);
node.Transform.Scale = new FVector3(2, 2, 2);

Héritage des Transformations

Les transformations se composent à travers la hiérarchie de la scène. La position d’un enfant dans l’espace mondial est le produit de toutes les transformations des ancêtres :

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's world position is (15, 0, 0)
// Access via child.GlobalTransform

GlobalTransform

En lecture seule GlobalTransform propriété de chaque Node fournit la matrice de transformation en espace mondial calculée après avoir composé toutes les transformations des ancêtres. Accédez au résultat via node.GlobalTransform.Matrix.

Matériaux

La bibliothèque comprend trois types de matériaux avec une complexité croissante :

LambertMaterial

Matériau classique uniquement diffus :

var material = new LambertMaterial("WoodMaterial");
material.Diffuse = new Vector4(0.6f, 0.4f, 0.2f, 1.0f);
material.Ambient = new Vector4(0.1f, 0.1f, 0.1f, 1.0f);
material.Transparency = 0.0f;

PhongMaterial

Étend Lambert avec des reflets spéculaires :

var material = new PhongMaterial("ShinyMetal");
material.Specular = new Vector4(0.8f, 0.8f, 0.8f, 1.0f);
material.Shininess = 50.0f;
material.SpecularPower = 32.0f;

PbrMaterial

Matériau de rendu physiquement basé utilisé par glTF 2.0 :

var material = new PbrMaterial("GoldPBR");
material.BaseColor = new Vector4(1.0f, 0.8f, 0.2f, 1.0f);
material.Metallic = 0.9f;
material.Roughness = 0.1f;
material.Occlusion = 1.0f;

Les matériaux PBR prennent en charge des emplacements de textures pour la couleur de base, le metallic/roughness, la normale, l’émissif et les cartes d’occlusion via des propriétés de chemin de texture de type chaîne.

Utilitaires Mathématiques

La bibliothèque fournit un ensemble de primitives mathématiques pour les opérations spatiales 3D :

Types de Vecteurs

Quaternion

Les quaternions représentent des rotations sans gimbal lock :

var rotation = new Quaternion(0, 0, 0, 1); // Identity
node.Transform.Rotation = rotation;

Matrix4

4x4 transformation matrices for composing transforms:

// Matrix operations are used internally by Transform
// and GlobalTransform for world-space computation

BoundingBox

Boîtes englobantes alignées sur les axes pour les requêtes spatiales :

// BoundingBox stores Minimum and Maximum FVector3 corners
// Used for frustum culling and spatial partitioning

Éléments de sommet

Les maillages peuvent contenir des couches de données supplémentaires par sommet au-delà des positions :

• VertexElementNormal – normales de surface pour les calculs d’éclairage.
• VertexElementUV – coordonnées de texture pour le mappage d’images sur la géométrie.
• VertexElementVertexColor – données de couleur RGBA par sommet.

Chaque élément de sommet possède un MappingMode (par point de contrôle, par sommet de polygone, ou par polygone) et un ReferenceMode (valeurs directes ou valeurs indexées).

Clips d’animation

Le Scene classe prend en charge les clips d’animation nommés via CreateAnimationClip() et GetAnimationClip(). Dans l’édition FOSS actuelle, la création et la recherche de clips d’animation sont fonctionnelles, mais les données d’images clés et la lecture ne sont pas encore implémentées.

var scene = new Scene();
var clip = scene.CreateAnimationClip("Walk");

// Retrieve by name
var found = scene.GetAnimationClip("Walk");
Console.WriteLine("Clip found: " + (found != null));

Prochaines étapes

Le prochain article couvre le travail avec les formats de fichiers 3D dans .NET – un guide pratique, format par format, pour OBJ, STL, glTF, FBX et 3MF avec des options de chargement/enregistrement et des modèles de conversion par lots.