Présentation de Aspose.3D FOSS pour .NET

Nous sommes ravis d’annoncer la disponibilité de Aspose.3D FOSS pour .NET – une bibliothèque gratuite et open-source pour travailler avec les formats de fichiers 3D dans les applications .NET. Construite comme une solution pure C# sans dépendances natives, la bibliothèque cible .NET 10.0 et versions ultérieures, la rendant accessible à un large éventail de projets et d’environnements.

Cet article passe en revue ce que la bibliothèque offre, comment démarrer, et les étapes suivantes.

Qu’est‑ce que Aspose.3D FOSS pour .NET ?

Aspose.3D FOSS pour .NET est une bibliothèque légère de traitement de fichiers 3D publiée sous la licence MIT. Elle fournit une API de graphe de scène qui vous permet de charger, inspecter, transformer et enregistrer des modèles 3D dans plusieurs formats largement utilisés. La bibliothèque est entièrement écrite en C# et ne nécessite aucun binaire natif externe ni aucune configuration spécifique à une plateforme.

Le code source est disponible sur GitHub : https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Points forts

• C# pur – pas de P/Invoke, pas de bibliothèques natives, aucune restriction de plateforme.
• .NET 10.0+ compatible.
• Sous licence MIT – utilisez‑le dans des projets personnels, commerciaux ou propriétaires sans restrictions.
• Architecture de graphe de scène – un arbre familier de nœuds, maillages, caméras et matériaux.
• Prise en charge multi‑format – lire et écrire les fichiers OBJ, STL, glTF 2.0, GLB, FBX, Collada et 3MF.

Démarrage rapide

Installation via NuGet

Ajoutez le package NuGet à votre projet :

dotnet add package Aspose.3D --version 26.1.0

Votre première conversion

Le cas d’utilisation le plus simple consiste à charger un fichier 3D dans un format et à l’enregistrer dans un autre. Voici une conversion en deux lignes de OBJ vers STL :

using Aspose.ThreeD;

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

La Scene classe est le point d’entrée central. Appelez scene.Open() avec un chemin de fichier pour charger un modèle, puis appelez Save() avec le chemin cible. La bibliothèque déduit le format à partir de l’extension du fichier.

Construire une scène à partir de zéro

Vous pouvez également construire des scènes de manière programmatique :

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

Cela crée une nouvelle scène, ajoute une primitive boîte en tant que nœud enfant sous la racine, la positionne aux coordonnées (1, 2, 3) et exporte le résultat sous forme de fichier glTF.

Chargement avec des options spécifiques au format

Lorsque vous avez besoin d’un contrôle plus fin du processus de chargement, chaque format fournit une classe d’options dédiée. Par exemple, charger un fichier STL avec des options explicites :

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

Le scene.Open() method accepte l’un des types d’options de chargement : ObjLoadOptions, StlLoadOptions, GltfLoadOptions, FbxLoadOptions, ou TmfLoadOptions.

Parcourir le graphe de scène

Une fois une scène chargée, vous pouvez parcourir l’arbre de nœuds pour inspecter ou modifier son contenu :

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

Ce modèle est utile pour le débogage, la génération de rapports sur le contenu du modèle, ou la modification sélective de parties d’une scène avant de la réexporter.

Appliquer des transformations

Le positionnement des nœuds dans l’espace 3D se fait via le Transform propriété sur chaque 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");

Les transformations suivent le modèle d’héritage parent‑enfant standard : la position d’un enfant dans l’espace mondial est la combinaison de sa transformation locale et de toutes les transformations des ancêtres jusqu’à la racine.

Ce qui est inclus

La bibliothèque est fournie avec un ensemble ciblé de fonctionnalités conçues autour du modèle de graphe de scène 3D.

Graphe de scène

Le graphe de scène est l’épine dorsale de l’API. Chaque fichier 3D est représenté comme une structure arborescente :

Primitives intégrées

L’édition .NET inclut des classes de formes paramétriques qui peuvent être attachées directement aux nœuds ou converties en Mesh:

• Box – boîte alignée sur les axes avec largeur, hauteur et profondeur configurables.
• Sphere – sphère paramétrique avec rayon configurable.
• Cylinder – cylindre paramétrique avec rayons et hauteur configurables.

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

Matériaux

La bibliothèque fournit plusieurs types de matériaux :

• LambertMaterial – matériau classique uniquement diffus avec des composantes de couleur ambiante, diffuse, émissive et réfléchissante.
• PhongMaterial – étend Lambert avec des reflets spéculaires et de la brillance.
• PbrMaterial – matériau de rendu physiquement basé avec couleur de base, métal, rugosité, occlusion et emplacements de textures.

Utilitaires Mathématiques

Le Aspose.ThreeD l’espace de noms inclut les primitives mathématiques essentielles :

• FVector3 – vecteur à simple précision de 3 composantes pour les positions, les directions et l’échelle. Utilisé par Transform.Translation et Transform.Scale.
• Vector4 – vecteur à simple précision de 4 composantes pour les points de contrôle et les normales.
• Matrix4 – matrice de transformation 4x4.
• Quaternion – représentation de rotation. Utilisé par Transform.Rotation.
• BoundingBox – boîte englobante alignée sur les axes pour les requêtes spatiales.

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

Options de chargement et d’enregistrement

Chaque format possède des classes d’options dédiées qui vous permettent de contrôler le comportement d’importation et d’exportation :

Par exemple, pour charger un fichier OBJ avec inversion des coordonnées et normalisation des normales :

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

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

Formats pris en charge

Le tableau suivant résume les formats que Aspose.3D FOSS pour .NET peut lire et écrire.

Guide de sélection des formats

Le choix du bon format dépend de votre cas d’utilisation :

• OBJ est idéal lorsque vous avez besoin d’une compatibilité maximale entre les outils 3D. Presque toutes les applications de modélisation peuvent lire et écrire OBJ. Il fonctionne bien pour l’échange de maillages, mais ne transporte que des informations de matériau de base via les fichiers MTL associés.
• STL est le format de choix pour les flux de travail d’impression 3D. Il stocke la géométrie triangulée brute sans matériaux ni hiérarchie de scène, ce qui correspond exactement à ce que le logiciel de découpe attend.
• glTF est la norme moderne pour le web et la 3D en temps réel. Il prend en charge les matériaux PBR, les hiérarchies de scène complètes, et est conçu pour une transmission efficace. Utilisez glTF lors de la création de visionneuses web ou pour cibler tout pipeline de rendu en temps réel.
• FBX est profondément intégré aux flux de travail de développement de jeux et de création de contenu numérique. Il prend en charge des données de scène riches, y compris les hiérarchies et les matériaux. Aspose.3D FOSS pour .NET prend en charge FBX importation et exportation en modes ASCII et binaire.
• 3MF est un format d’impression 3D moderne qui prend en charge des métadonnées riches, des matériaux et des scènes multi-objets dans un seul paquet basé sur ZIP.

Limitations connues

Scene.Render() est non pris en charge dans l’édition FOSS. L’appel de cette méthode lèvera une NotImplementedException. La bibliothèque est conçue pour le traitement 3D basé sur des fichiers – chargement, manipulation, transformation et sauvegarde de modèles – plutôt que pour le rendu en temps réel sur un affichage.

Open source et licence

Aspose.3D FOSS for .NET est publié sous le Licence MIT. Cela signifie que vous êtes libre de :

• Utiliser la bibliothèque dans des applications commerciales et propriétaires.
• Modifiez le code source pour l’adapter à vos besoins.
• Distribuez la bibliothèque dans le cadre de votre propre logiciel.

Il n’y a aucun frais de redevance, aucune limite d’utilisation et aucune exigence d’attribution au-delà de ce que spécifie la licence MIT.

Le code source complet est hébergé sur GitHub, et les contributions sont les bienvenues : https://github.com/aspose-3d-foss/Aspose.3D-FOSS-for-NET

Configuration requise

Premiers pas

Voici les ressources pour vous aider à démarrer :

• Documentation – des guides complets et des présentations d’API sont disponibles sur le Aspose.3D site de documentation.
• Base de connaissances – des articles pratiques et des conseils de dépannage dans le Aspose.3D KB.
• Référence API – référence détaillée des classes et des méthodes sur le Référence de l’API Aspose.3D.
• Code source – parcourir et contribuer sur GitHub.
• NuGet – le package est publié sous Aspose.3D sur NuGet.

Cas d’utilisation courants

Voici quelques scénarios pratiques où Aspose.3D FOSS pour .NET s’intègre bien :

Pipelines de conversion de formats

De nombreuses équipes reçoivent des actifs 3D dans un format mais en ont besoin dans un autre. Une équipe de conception peut travailler en FBX tandis que l’équipe web a besoin de glTF. La bibliothèque vous permet de créer des pipelines de conversion automatisés :

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

Avant d’intégrer un actif 3D dans votre application, vous pouvez souhaiter valider son contenu — vérifier le nombre de nœuds, vérifier la géométrie, ou confirmer que les éléments attendus sont présents :

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

Assemblage de scène

Vous pouvez charger plusieurs modèles et les combiner en une seule 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");

Prochaines étapes

Dans les prochains articles, nous couvrirons :

• Une plongée approfondie dans les fonctionnalités clés de l’API de graphe de scène, des matériaux et des utilitaires mathématiques.
• Un guide pratique pour travailler avec chaque format 3D pris en charge — OBJ, STL, glTF, FBX et 3MF — incluant les options de chargement/enregistrement et les modèles de conversion par lots.

Restez à l’écoute, et n’hésitez pas à explorer la bibliothèque et à partager vos retours sur GitHub.