1 Introduction
DirectX 9.0 vient de sortir et, comme la nouvelle gamme de produit Microsoft, nous avons à notre disposition au sein du SDK des classes .NET pour nous permettre de goûter aux joies du développement 3D avec la simplicité de mise en œuvre que l’on connaît avec .NET.
Le but final de cette série d’articles sera de réaliser un outil pour aménager un intérieur grâce à une visualisation en 3D des meubles et des décorations. Nous nous appuierons sur C#.NET comme langage et sur le Visual Studio .NET pour l’environnement.
2 Installation
L’installation de DirectX 9.0 et de son SDK est d’une grande simplicité. La première étape consiste bien sûr à télécharger l’ensemble à cette adresse :
http://www.microsoft.com/downloads/details.aspx?FamilyId=592393A7-C677-4023-8B27-94E61141E9C6&displaylang=en
L’installation en elle-même ne pose aucun problème. Une fois terminée, Visual Studio .NET se voit agrémenter d’un nouvel assistant qui permet de développer un projet qui fait appel à DirectX Managed. Cet assistant prend en charge les phases d’initialisation et fournit même un exemple d’utilisation.
Toutefois, afin de bien maîtriser notre outil, nous nous passerons d’assistants pour vraiment tout mettre en œuvre nous même.
L’installation de DirectX Managed ajoute également une documentation au sein du MSDN afin de référencer les classes .NET qui ont été rajoutées. Hélas, à l’heure actuelle, cette documentation est extrêmement incomplète et ne permet pas de faire grand-chose. Microsoft n’a pour l’instant pas donné de date quand à la sortie finale de cette documentation.
3 L’interface
Avant de nous lancer dans le monde merveilleux de la 3D Temps réel, nous devons nous équiper d’une jolie interface qui saura héberger et faire vivre tout ce beau monde. Dans le cadre de notre projet, notre interface se divisera en trois parties distinctes.
D’une part, nous aurons sur la partie gauche de notre écran une treeview qui référencera les objets disponibles à mettre dans notre maison (chaises, tables, décorations, …).
Deuxièmement, nous aurons sur la partie haute une listview qui référencera tous les objets déjà présents dans la scène.
Finalement, nous aurons notre fenêtre de rendu dans la partie base ou sera réalisé le dessin de notre intérieur.
1. Dans un premier temps, nous allons définir une fenêtre standard que l’on nommera frmMain et qui portera le titre de notre application «InteriorWise».
2. Puis nous allons positionner une treeview nommée trvView sur la partie gauche de notre fenêtre grâce à la propriété Dock=Left.
3. Afin de fournir un moyen de dimensionnement simple, nous allons glisser un splitter qui viendra s’accrocher sur la partie droite de notre treeview.
4. Nous allons ensuite occuper l’espace restant avec un panel dont la propriété Dock sera positionnée à Fill.
5. Dans ce panel, nous allons créer une listview lstView dans la partie haute (Dock=Top). Puis nous glissons un autre splitter avec sa propriété Dock positionnée à TOP.
6. Finalement, il ne reste plus qu’à mettre une picturebox pctBox dans la partie restante (Dock=Fill).
7. Pour compléter notre interface, nous allons rajouter un menu qui contiendra pour l’instant un seul sous-menu Fichier/Quitter.
8. La treeview contiendra trois nœuds racines qui seront : « chaises », « tables » et « canapés ».
9. Au niveau du code, nous avons juste la gestion du sous menu Fichier/Quitter a développer :
private void mnuQuit_Click(object sender, System.EventArgs e)
{
Application.Exit();
}
Nous pouvons le constater aisément, ce n’est pas la partie interface Windows Forms qui nous posera problème.
4 Initialisation
Pour utiliser DirectX Managed, nous allons devoir référencer les assemblies suivantes :
- Microsoft.DirectX.DirectX
- Microsoft.DirectX.Direct3D
- Microsoft.DirectX.Direct3DX
Pour communiquer avec la carte graphique qui se chargera du dessin, nous allons avoir besoin d’une instance de la classe Device fournit par DirectX Managed (DXM).
Pour pouvoir créer cette instance nous devons faire passer à la carte de nombreux renseignements. Pour cela, nous allons remplir une structure PresentParameters.
Afin de clarifier l’ensemble, nous allons rassembler la gestion de DXM dans une classe statique que nous allons appeler DirectXCore.
Cette classe va contenir une méthode publique qui nous permettra d’initialiser DXM en lui faisant passer le contrôle Windows Forms où aura lieu le rendu.
Nous allons faire le choix d’une gestion du calcul géométrique par le processeur afin d’être le plus compatible possible avec les cartes du marché.
Le code de cette classe est le suivant :
using System;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;
using System.Windows.Forms;
namespace InteriorWise
{
public class DirectXCore
{
// instance représentant la carte graphique
static Device device3D = null;
public static void ErrorManage(string msg)
{
MessageBox.Show(msg, "InteriorWise Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
Application.Exit();
}
public static void InitDXM(Control ctrl)
{
try
{
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
presentParams.BackBufferFormat = Format.X8R8G8B8;
presentParams.AutoDepthStencilFormat = DepthFormat.D24S8;
presentParams.EnableAutoDepthStencil = true;
presentParams.BackBufferCount = 2;
device3D = new Device(0, DeviceType.Hardware, ctrl, CreateFlags.SoftwareVertexProcessing, presentParams);
}
catch (Exception ex)
{
ErrorManage(ex.Message);
}
}
}
}
La création du Device nécessite que l’on précise plusieurs renseignements au niveau du PresentParameters :
- Windowed : Spécifie si l’on est en plein écran ou en fenêtré.
- SwapEffect : Traitement à effectuer quand on change d’images (Dans notre cas, nous détruisons le contenu de l’image précédente).
- BackBufferFormat : Format du pixel d’affichage (ici 32 bits avec 8 bits par composante, sans gestion de la transparence).
- AutoDepthStencilFormat : Format du zbuffer (ici 24 bits pour gérer la profondeur).
- BackBufferCount = Nombre de buffers d’affichage (ici 2 afin d’avoir un affichage fluide).
En plus de ces renseignements, nous indiquons lors de l’instanciation du Device que nous souhaitons un device matériel (DeviceType.Hardware) et une gestion de la géométrie par le processeur (CreateFlags.SoftwareVertexProcessing).
A partir ce cet instant, nous disposons de notre intermédiaire pour dialoguer avec la carte graphique.
5 Boucle de rendu
Afin d’avoir un affichage fluide, il va nous falloir dessiner plusieurs fois par seconde notre scène. Mais avant cela, nous devons initialiser notre DirectXCore en ajoutant cette ligne dans le Load de notre formulaire :
private void frmMain_Load(object sender, System.EventArgs e)
{
DirectXCore.InitDXM(pctBox);
}
Pour la gestion du rendu, nous allons ajouter une méthode Render à notre formulaire qui sera appelée à chaque fois que nous souhaitons redessiner notre intérieur.
De plus, le main de notre application va être modifié afin d’appeler aussi souvent que possible notre méthode de rendu :
[STAThread]
static void Main()
{
frmMain frm = new frmMain();
frm.Show();
while (frm.Created)
{
frm.Render() ;
Application.DoEvents();
}
}
La fonction minimale que doit effectuer le programme pour afficher une image se découpe en deux parties : Initialiser l’image et Terminer l’image. Pour remplir ces fonctions, DXM nous fournit deux méthodes au travers du Device : BeginScene() et EndScene(). Nous allons encapsuler cette gestion dans notre classe DirectXCore via deux méthodes Begin et End :
public static void Begin()
{
device3D.BeginScene();
}
public static void End()
{
device3D.EndScene();
device3D.Present();
}
La fonction End() fait également appel à la méthode Present() qui se charge de transférer l’image depuis le buffer de rendu vers le contrôle contenant.
Finalement et pour compléter notre fonction de rendu, nous allons ajouter une méthode à DirectXCore pour effacer l’intégralité de la zone de dessin :
public static void Clear(System.Drawing.Color color)
{
ClearFlags flags = ClearFlags.Target | ClearFlags.ZBuffer | ClearFlags.Stencil;
device3D.Clear(flags, color, 1.0f, 0);
}
Nous faisons ici appel à la méthode Clear() qui permet de vider les buffers de rendus et de profondeur afin de totalement réinitialiser la scène.
Au niveau de notre formulaire, la méthode Render() s’écrit donc comme ceci :
private void Render()
{
DirectXCore.Begin();
DirectXCore.Clear(Color.DarkGray);
DirectXCore.End();
}
6 Conclusion
Cette première approche nous a permis de mettre en œuvre notre interface et une première ébauche de communication avec la carte graphique. Notre prochaine étape consistera à charger et afficher des objets qui seront par la suite inclus dans notre interface.