Programmer Managed DirectX sous C# - Tutoriel 1Date de publication : 04/08/2006 , Date de mise à jour : 04/08/2006
Par
funky.data (Tutoriaux C# - DirectX9) (NXEngine - Mon Moteur 3D)
Ce tutoriel vous apprendra comment créer une application DirectX en utilisant C#. Nous verrons une brève présentation de la technologie DirectX ainsi que son utilisation dans un programme C#.
I. Créez votre projet "Managed DirectX" en C#
I.1. Pré requis
I.2. Préparation de votre projet
II. Présentation et Initialisation de Direct3D
II.1. La classe "Device"
II.2. Les "presentationParameters"
II.3. La procédure d'initialisation du Device Direct3D
III. Utilisation de Direct3D
III-1. Les évènements
III-1-1. L'évènement "DeviceReset"
III-1-2. L'évènement "DeviceLost"
III-1-3. L'évènement "Disposing"
III-1-4. L'évènement "DeviceResizing"
III-2. La boucle de rendu
III-2-1. L'effacement
III-2-2. Rendu de la scène
III-2-3. L'appel de la boucle de rendu
III-3. Récapitulatif
I. Créez votre projet "Managed DirectX" en C#
I.1. Pré requis
- Visual Studio .NET 2003 ou Visual C# Express Edition (téléchargeable gratuitement ici).
- Le SDK de DirectX 9 disponible ici.
I.2. Préparation de votre projet
Téléchargez et installez le SDK de DirectX.
Ouvrez Visual Studio .NET ou Visual C# Express Edition et créez un nouveau projet "Application Windows" que vous pourrez appeler "D3D Tutoriel 1" par exemple.
 Créez un nouveau projet
Une fois le projet créé faite un click droit sur "Références" dans le panneau "Explorateur de Solution" puis cliquez sur "Ajouter une référence".
 Ajouter les références à votre projet
Dans la fenêtre nouvellement ouverte par l'IDE, faite défiler la liste des composants jusqu'à trouver "Microsoft.DirectX". Vous devriez avoir deux références de ce composant. Une en version 1.1 et l'autre en version 2.0. Sélectionnez le composant en version 1.1. En effet, bien qu'aillant bien avancée la version 2.0 est encore un peu trop jeune et peu causer de nombreux petits soucis. Par mesure de sécurité donc nous utiliserons donc la version 1.1.
Trouvez maintenant la référence au composant "Microsoft.DirectX.Direct3D" et "Microsoft.DirectX.Direct3DX "et sélectionnez les également...
 Ajouter les composants DirectX à votre projet
Cliquez sur "OK" : les références s'ajoutent à votre projet dans l'arbre des références du panneau d'explorateur de solution.
Pour finir allez dans le code source de la Form utilisée par votre application et ajoutez les clauses "using" suivantes afin de référencer les composants que nous venons d'ajouter :
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D; |
II. Présentation et Initialisation de Direct3D
II.1. La classe "Device"
La classe "Device" est la base de tout rendu dans l'environnement Direct3D. Voici donc la syntaxe du constructeur qui va nous intéresser dans ce tutoriel :
public Device (
System.Int32 adapter,
Microsoft.DirectX.Direct3D.DeviceType deviceType ,
System.Windows.Forms.Control renderWindow ,
Microsoft.DirectX.Direct3D.CreateFlags behaviorFlags,
Microsoft.DirectX.Direct3D.PresentParameters presentationParameters) |
Voyons les paramètres du constructeur :
| Paramètres |
Description |
| adapter |
Défini l'entier représentant l'adaptateur (carte vidéo) que DirectX devra utiliser. En général on utilise l'adapter par défaut c'est à dire l'adapteur 0. |
| deviceType |
Le deviceType défini quel type de device on veut créer. En général on utilisera un device de type "Hardware" ( DeviceType.Hardware) mais on peu utiliser également le type "Rasterizer". Ce type sera utile notamment pour des phases de debugage ou pour tester des effets qui ne peuvent être gérés par l'adapter utilisé par le device Direct3D. Il va sans dire que ce mode est extrêmement lent et que son utilisation n'est pas conseillée dans d'autres cas que ceux cités précédemment. |
| renderWindow |
Défini le contrôle qui va "accueillir" Direct3D. Cela peut-être un Form, un Panel, une PictureBox... A définir selon vos besoins. |
| behaviorFlags |
Défini le comportement de Direct3D une fois son initialisation effectuée. Il existe beaucoup de flags et je vous invite à lire la documentation de Direct3D à ce sujet. Disons simplement que les trois plus utiles vont être :
- CreateFlags.HardwareVertexProcessing
- CreateFlags.SoftwareVertexProcessing
- CreateFlags.PureDevice
Dans le cas où on initialise le flag "SoftwareVertexProcessing" toutes les opérations de vertex seront réalisées par le CPU. C'est bien entendu plus lent que le "HardwareVertexProcessing" mais ce flag est compatible avec toutes les cartes vidéos.
Pour le flag "PureDevice" nous verrons ça dans un tutoriel suivant.
Pour information il est bien sur possible de combiner ces flags.
|
| presentationParameters |
Enfin ce dernier paramètre va définir la présentation du device Direct3D à l'écran. Je détaille cette structure dans le chapitre suivant. |
II.2. Les "presentationParameters"
Afin de correctement initialiser notre device Direct3D il est indispensable de bien paramétrer les "presentationParameters". Tous d'abord créons notre structure :
PresentParameters presentParams = new PresentParameters(); |
Nous allons voir dans ce chapitre le minimum requis pour initialiser un device Direct3D fonctionnel. En l'occurrence deux variables de "presentParams" nous intéresse ici :
- Windowed (Booléen définissant si Direct3D doit se comporter en mode fenêtré ou non).
- SwapEffect (Défini le comportement du BackBuffer. Pour l'instant on utilisera "SwapEffect.Discard" qui défini que l'on annule les données du BackBuffer si celui-ci n'est pas prés à être présenté).
II.3. La procédure d'initialisation du Device Direct3D
Voici le code source utilisant ce que nous avons vu jusqu'a présent, à savoir, l'initialisation des "PresentParameters" de notre device et bien sûr l'initialisation du device Direct3D. Ce code source est bien entendu à utiliser dans le code source de la Form de notre projet :
private Device device = null;
public void InitializeGraphics()
{
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
} |
III. Utilisation de Direct3D
III-1. Les évènements
Nous allons voir maintenant très rapidement comment gérer les évènements que nous renvoi le device Direct3D. Je vais vous présenter ici 4 évènements qui vont nous être utile afin de bien "manager" notre device.
III-1-1. L'évènement "DeviceReset"
Comme son nom l'indique cet évènement est envoyé lors d'un reset du device Direct3D. Nous verrons comment gérer cet évènement plus en détails dans un prochain tutoriel. Je vous indique simplement comment intercepter cet évènement qui nous sera utile lors de nos prochaines leçons :
| Interception de l'évènement 'DeviceReset' |
device.DeviceReset += new EventHandler(OnResetDevice);
private void OnResetDevice(object sender, EventArgs e)
{
if (device == null || device.Disposed)
return;
} |
III-1-2. L'évènement "DeviceLost"
Pour faire simple disons que cet évènement est déclencher lorsque le container du device Direct3D (une Form par exemple) perd sa synchronisation avec le device.
| Interception de l'évènement 'DeviceReset' |
private bool isDeviceLost = false;
device.DeviceLost += new EventHandler(OnLostDevice);
private void OnLostDevice(object sender, EventArgs e)
{
isDeviceLost = true;
} |
III-1-3. L'évènement "Disposing"
Cet évènement est déclencher lorsque le device à reçu une demande de fermeture.
| Interception de l'évènement 'DeviceReset' |
private bool isTerminated = false;
device.Disposing += new EventHandler(OnDisposingDevice);
private void OnDisposingDevice(object sender, EventArgs e)
{
isTerminated = true;
device = null;
} |
III-1-4. L'évènement "DeviceResizing"
Cet évènement est déclencher lorsque le device (en fait son container) est redimensionné.
| Interception de l'évènement 'DeviceResizing' |
device.DeviceResizing += new EventHandler(OnResizingDevice);
private void OnResizingDevice(object sender, EventArgs e)
{
if (device == null || device.Disposed)
return;
if (device.CheckCooperativeLevel() == false || this.WindowState == FormWindowState.Minimized ||
this.Activate == false)
{
e.Cancel = true;
}
if (this.WindowState != FormWindowState.Minimized)
{
if (this.Size.Width < 320 || this.Size.Height < 200)
this.Size = new Size(320, 200);
}
} |
III-2. La boucle de rendu
Nous allons maintenant apprendre à utiliser le device Direct3D que nous venons de créer. La première étape consiste à réaliser une boucle de rendu. Voyons de quelles fonctions se composent cette boucle :
- Effacement du ou des buffers
- Début de la scène
- Dessin des éléments composants la scène
- Fin de la scène
- Affichage du buffer
III-2-1. L'effacement
La première étape à réaliser dans notre boucle est donc l'effacement des différents buffers qu'utilise le device Direct3D. Pour cela nous appellerons la fonction "Clear" de la classe "Device". Voici le détail de cette fonction :
public void Clear(
ClearFlags flags,
Color color,
float zdepth,
int stencil
); |
Détaillons les paramètres de cette fonction :
| Paramètres |
Description |
| flags |
Défini les buffers concernés par cet effacement. Pour le moment nous effacerons 2 buffers : le "Target" (backbuffer primaire) et le "ZBuffer" (Buffer stockant en gros les informations de profondeur de la scène). |
| color |
Défini la couleur qui sera utilisée pour l'effacement. |
| zdepth |
Défini la valeur (de 0 à 1) qui sera placée dans le ZBuffer aprés effacement. |
| stencil |
Représente la valeur à stocker dans chaque Stencil Buffer. Je rentre pas dans les détails, c'est inutile pour l'instant. |
III-2-2. Rendu de la scène
Seconde étape, le rendu de la scène en elle même. Tout d'abord nous devons indiquez au device Direct3D que nous allons rendre la scène. Pour ce faire il faut lancer la fonction "BeginScene".
Ensuite, nous lançons le rendu de nos éléments composants notre scène. Pour l'instant nous n'affichons rien...
Enfin nous indiquons au device Direct3D que le rendu de notre scène est terminé par l'appel de la fonction "EndScene" et nous présentons le résultat à l'écran en appelant la fonction "Present".
Concrètement voici l'appel de ces fonctions :
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, 0, 1.0f, 0);
device.BeginScene();
device.EndScene();
device.Present(); |
III-2-3. L'appel de la boucle de rendu
L'appel de la boucle de rendu ne peut être effectuée dans une boucle simple dans la mesure où nous devons nous assurer avant que le rendu et la présentation peuvent être réalisé. Pour cela deux possibilités s'offre à nous.
La première consiste à utiliser les évènements de la Form en l'occurrence, ici, l'évènement "Paint".
La seconde consiste à réaliser les tests nous même afin de définir si oui ou non l'application est apte à réaliser le rendu. Nous ne nous occuperons pas de réaliser cette fonction de test dans ce tutoriel dans la mesure ou ces tests font appel à pas mal de fonctions que nous ne verront que plus tard. Je traiterais ce point ultérieurement.
Nous allons donc utiliser l'évènement "Paint" pour lancer notre rendu. Dans un premier temps il convient d'attacher une fonction à l'appel de cet évènement :
this.Paint += new PaintEventHandler(this.Render);
private void Render(object sender, PaintEventArgs e)
{
device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, 0, 1.0f, 0);
device.BeginScene();
device.EndScene();
device.Present();
} |
III-3. Récapitulatif
Nous avons donc vu comment :
- Initialiser un device Direct3D
- Intercepter les évènements retourné par le device
- Réaliser un appel à une boucle de rendu
- Réaliser une boucle de rendu
Voici, pour récapituler, le code source de ce tutoriel :
| Form1.cs | public partial class Form1 : Form
{
private Device device = null;
public Form1()
{
InitializeComponent();
InitializeGraphics();
this.Paint += new PaintEventHandler(this.Render);
}
public void InitializeGraphics()
{
PresentParameters presentParams = new PresentParameters();
presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
}
private void Render(object sender, PaintEventArgs e)
{
device.Clear(ClearFlags.Target, 0, 1.0f, 0);
device.BeginScene();
device.EndScene();
device.Present();
}
} |
 
Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur.
La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.
|