Programmer Managed DirectX sous C# - Tutoriel 1

• Visual Studio .NET 2003 ou Visual C# Express Edition (téléchargeable gratuitement ici).
• Le SDK de DirectX 9 disponible ici.

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.

Une fois le projet créé, faites un clic droit sur "Références" dans le panneau "Explorateur de Solution" puis cliquez sur "Ajouter une référence".

Dans la fenêtre nouvellement ouverte par l'IDE, faites 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'étant bien avancée la version 2.0 est encore un peu trop jeune et peut 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...

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;

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 :

Afin de correctement initialiser notre device Direct3D il est indispensable de bien paramétrer les "presentationParameters". Tout 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éressent ici :

• Windowed (booléen définissant si Direct3D doit se comporter en mode fenêtré ou non) ;
• SwapEffect (définit le comportement du BackBuffer. Pour l'instant on utilisera "SwapEffect.Discard" qui définit que l'on annule les données du BackBuffer si celui-ci n'est pas prêt à être présenté).

Voici le code source utilisant ce que nous avons vu jusqu'à 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;

// Nous initialisons notre device Direct3D ici
public void InitializeGraphics()
{
    // Définition des PresentParameters
    PresentParameters presentParams = new PresentParameters();

    presentParams.Windowed = true;
    presentParams.SwapEffect = SwapEffect.Discard;

    // Creation de notre device
    device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);

Nous allons voir maintenant très rapidement comment gérer les évènements que nous renvoie le device Direct3D. Je vais vous présenter ici quatre évènements qui vont nous être utiles afin de bien "manager" notre device.

III-A-1. L'évènement "DeviceReset"▲

// Après l'initialisation du device Direct3D
device.DeviceReset += new EventHandler(OnResetDevice);

// Fonction appelée lors de l'interception de l'évènement "DeviceReset"
private void OnResetDevice(object sender, EventArgs e)
{
        // Si le device n'est pas initialisé ou a été libéré on sort directement
    if (device == null || device.Disposed)
        return;

        // Traitement de l'évènement
}

III-A-2. L'évènement "DeviceLost"▲

// On ajoute une variable locale
private bool isDeviceLost = false;

// Après l'initialisation du device Direct3D
device.DeviceLost += new EventHandler(OnLostDevice);

// Fonction appelée lors de l'interception de l'évènement "DeviceLost"
private void OnLostDevice(object sender, EventArgs e)
{
        // On initialise la variable locale à TRUE
    isDeviceLost = true;
    
    // Traitement de l'évènement 
}

III-A-3. L'évènement "Disposing"▲

// On ajoute une variable locale
private bool isTerminated = false;

// Après l'initialisation du device Direct3D
device.Disposing += new EventHandler(OnDisposingDevice);

// Fonction appelée lors de l'interception de l'évènement "Disposing"
private void OnDisposingDevice(object sender, EventArgs e)
{
        // On initialise la variable locale à TRUE
    isTerminated = true;
    
    // Traitement de l'évènement 
    device = null;
}

III-A-4. L'évènement "DeviceResizing"▲

// Après l'initialisation du device Direct3D
device.DeviceResizing += new EventHandler(OnResizingDevice);

// Fonction appelée lors de l'interception de l'évènement "DeviceResizing"
private void OnResizingDevice(object sender, EventArgs e)
{
        // Si le device n'est pas initialisé ou a été libéré on sort directement
        if (device == null || device.Disposed)
        return;
    
    // Traitement de l'évènement 
    if (device.CheckCooperativeLevel() == false || this.WindowState == FormWindowState.Minimized ||
        this.Activate == false)
    {
        e.Cancel = true;
    }
        
        // On définit comme 320x200 la résolution minimum
    if (this.WindowState != FormWindowState.Minimized)
    {
        if (this.Size.Width < 320 || this.Size.Height < 200)
            this.Size = new Size(320, 200);
    }
}

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 compose cette boucle :

1. effacement du ou des buffers ;
2. début de la scène ;
3. dessin des éléments composant la scène ;
4. fin de la scène ;
5. affichage du buffer.

III-B-1. L'effacement▲

public void Clear(
    ClearFlags flags,
    Color color,
    float zdepth,
    int stencil
);

III-B-2. Rendu de la scène▲

device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, 0, 1.0f, 0);
device.BeginScene();
// TODO : Rendu des éléments 3D de notre scène
device.EndScene();
device.Present();

III-B-3. L'appel de la boucle de rendu▲

// Dans le constructeur de la Form
this.Paint += new PaintEventHandler(this.Render);

// La fonction réalisant le rendu de la scène Direct3D
private void Render(object sender, PaintEventArgs e)
{
        device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, 0, 1.0f, 0);
        device.BeginScene();
        // TODO : Rendu des éléments 3D de notre scène
        device.EndScene();
        device.Present();
}

Nous avons donc vu comment :

• initialiser un device Direct3D ;
• intercepter les évènements retournés 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 :

public partial class Form1 : Form
{
    // Notre device
    private Device device = null;

    // Initialisation de la form
    public Form1()
    {
        InitializeComponent();
        // Appel de la procédure d'initialisation du device Direct3D
        InitializeGraphics();
        // Evènement pour la boucle de rendu
        this.Paint += new PaintEventHandler(this.Render);
    }

    // Procédure d'initialisation du device Direct3D
    public void InitializeGraphics()
    {
        // Définition des PresentParameters
        PresentParameters presentParams = new PresentParameters();
        presentParams.Windowed = true;
        presentParams.SwapEffect = SwapEffect.Discard;

        // Création de notre device
        device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
    }

    // La boucle de rendu
    private void Render(object sender, PaintEventArgs e)
    {
        // Effacement de la scène
        device.Clear(ClearFlags.Target, 0, 1.0f, 0);
        // Début de la scène
        device.BeginScene();
        
        // TODO : Rendu des éléments 3D de notre scène

        // Fin de la scène
        device.EndScene();
        // Présentation de la scène à l'écran
        device.Present();
    }
}

Index - Tutoriel Suivant - Ce Tutoriel en PDF