Catégories: C | C++ | DirectX | Langage | Article

Un article de ToutProgrammer.com.

[modifier] Introduction

Avant l'arrivée de Microsoft Windows 95 et encore quelque temps après, la plupart des jeux vidéo développés pour l'univers PC l'étaient pour DOS. En effet, les versions de Windows disponibles avant 1995 (Windows 3.1 et 3.1 Workstation) ne fournissaient aucune moyen réel pour réaliser des jeux. Dès les premières versions de Windows il était possible de réaliser des jeux, mais comme il n'y avait pas d'API dédiée au multimédia les jeux réalisés dépassaient rarement le niveau technique d'une dame de pique.

Alors que les joueurs étaient habitués à un plus haut niveau technologique avec par exemple des jeux en 3D, il n'était pas concevable pour Microsoft de voir que le DOS pouvait mettre en péril la sécurité de son nouveau système d'exploitation en permettant des accès aux matériels sans aucune sécurité. Même si pendant encore quelque temps, Microsoft devait permettre aux joueurs d'utiliser leurs anciens jeux DOS avec Windows, ceci commença à changer à partir de 1997/1998.

En attendant, dès 1995, Microsoft proposa une nouvelle API avec son nouveau système d'exploitation fétiche: DirectX. Ce jeu de composants était pour la première fois en mesure d'effectuer des accès directs aux matériels présents sur le système PC depuis Windows. Que ce soit la carte vidéo, la carte son ou le réseau, il fallait que le nouveau Windows soit une plateforme crédible pour la réalisation de jeux vidéo.

DirectX n'est pas le seul kit de développement pour la réalisation d'applications multimédias comme les jeux. Il existe en effet, d'autres API mais aucune ne propose à ce jour un ensemble complet et homogène touchant aussi bien le graphisme, le son, le réseau, les joysticks, les volants, ... Malgré tout, si vous être intéressé par ces autres SDK, vous pouvez vous reportez aux différents liens ci-dessous:

• OpenGL est une API de Silicon Graphics destinée principalement à la réalisation de logiciels 3D. Elle a l'avantage d'exister sur un grand nombre de plateformes et pas seulement sous Microsoft Windows,
• SDL (Simple DirectMedia Layer) est une API OpenSource qui permet de compléter les fonctionnalités d'OpenGL dans le domaine autre que celui de la 3D. Elle rejoint en cela l'API DirectX sur bien des sujets. SDL est distribuée sous licence GNU LGPL,
• ClanLib est une bibliothèque OpenSource multi-plateforme similaire à SDL. Elle est distribuée sous licence de type BSD.

[modifier] Téléchargement de DirectX

Le site officiel de Microsoft pour les développeurs est le site MSDN. Une section spéciale est dédiée au produit DirectX à l'adresse: http://msdn2.microsoft.com/fr-fr/directx/default.aspx. Il ne faut pas confondre ce site avec le site pour les utilisateurs finaux (les joueurs) que l'on trouve à l'adresse: http://www.gamesforwindows.com/en-US/AboutGFW/Pages/DirectX10.aspx.

Veillez à ne pas vous tromper de fichier à télécharger car il existe au moins 2 versions de DirectX dont le but n'est pas du tout le même:

Veillez à ne pas vous tromper de fichier à télécharger car il existe au moins 2 versions de DirectX dont le but n'est pas du tout le même:

• Le runtime est le plus petit paquetage (environ 165Mo tout de même) qui ne propose que le minimum pour utiliser DirectX avec les jeux. C'est toujours celui-ci que l'on retrouve distribué avec les jeux afin de permettre au joueur de faire une mise à jour aisée de sa version de DirectX avant d'exécuter le jeu. Ce n'est pas cette version qu'il faut utiliser pour développer avec DirectX,
• Le SDK est un beau "bébé" de plus de 220Mo (pour la version 9.0b). Ce gros paquetage contient toutes les bibliothèques nécessaires à la réalisation d'applications multimédias avec DirectX. Il contient également des programmes de diagnostic ainsi que de nombreux exemples en C++, Visual Basic .NET et C#. Vous y trouverez aussi une aide sur les API en format Aide pour Windows. Il contient également bien entendu le runtime standard. C'est cette version que nous allons télécharger.

Au moment de la réalisation de ce document, la version de DirectX publique est la version 9.0b. Elle est téléchargeable ici.

[modifier] Installation du kit de développement

Une fois le téléchargement du SDK DirectX effectué, il nous reste à l'installer. Prévoyez pour cela environ 2 fois 330Mo d'espace pour DirectX 9.0b sur votre disque dur. Les premiers 330Mo permettront de décompresser temporairement l'archive avant son installation nécessitant elle aussi 330Mo.

Une fois l'archive auto-dézipée dans le répertoire temporaire, vous arriverez sur l'écran d'accueil suivant:

Vous avez juste à cliquer "Next >" pour arriver sur l'écran suivant:

[modifier] Propriétés de DirectX

Après l'installation du SDK, une nouvelle icône est disponible dans le panneau de configuration de Windows:

Cette icône (non disponible pour une installation de DirectX normale) permet de configurer plus finement DirectX en fonction des tests que vous effectuerez. Lorsque vous double-cliquez dessus, vous arrivez sur une boite de dialogue à onglets comme celle-ci:

Nous allons voir maintenant une bref description des différents onglets.

[modifier] DirectX

Ce premier onglet permet de lancer DxDiag, l'application de diagnostic de DirectX. Grâce à celle-ci vous pourrez vérifier que le matériel est bien reconnu et que les différentes bibliothèques de DirectX ne provoquent pas de conflits.

[modifier] Direct3D

Grâce à cet onglet, vous pouvez connaître les différents pilotes de périphérique en charge de la 3D. Vous pouvez également modifier la quantité d'informations à retourner en mode debug. Enfin, vous pouvez indiquez si vous souhaitez utiliser la version de debug de Direct3D ou la version normale.

[modifier] DirectDraw

Cet onglet présente différentes options ou informations de DirectDraw. On y voit notamment l'ensemble des modes vidéos supportés par votre carte graphique. En cliquant le bouton Advanced Settings ..., vous pouvez également activer ou désactiver des accélérations matérielles afin de voir comment se comporte votre application DirectX lorsque le matériel ne fournit pas une certaine technologie (par exemple MMX).

[modifier] DirectInput

Comme son nom l'indique, cet onglet concerne le composant DirectX DirectInput. Ce dernier permet la gestion des entrées comme les joysticks. Dans cet onglet, vous pouvez définir le niveau d'information lors de la phase de déboguage de votre application. Vous pouvez également définir ici si vous souhaitez utiliser la version debug de DirectInput ou la version joueur.

[modifier] DirectMusic

Cet onglet permet d'avoir la liste des périphériques dédiés à la musique. On y trouve en particulier les différents pilotes qui supportent le format MIDI (Musical Instrument Digital Interface) ainsi que les synthétiseurs disponibles. Vous pouvez également définir ici le niveau de trace lors de la phase de débogage.

[modifier] DirectPlay

L'onglet DirectPlay permet de contrôler le débogage lors de la conception d'applications multimédia en réseau. Vous pouvez donc ici définir le niveau d'information des traces en mode debug ainsi que la version de DirectPlay à utiliser (debug ou joueur).

[modifier] DirectSound

DirectSound est le composant DirectX dédié au son. C'est lui qui servira à l'ambiance sonore d'un jeu (à ne pas confondre avec DirectMusic pour l'ambiance musicale). Cet onglet permet de contrôler le niveau de trace lors du débogage. Vous y trouverez également quelques informations sur les périphériques utilisés pour l'enregistrement ou la restitution des bruitages.

[modifier] DirectShow

Enfin, ce dernier onglet permet de contrôler le niveau des traces lors de la phase de débogage d'applications qui utilisent DirectShow (composant dédié à l'affichage de vidéos).

[modifier] Concepts de base de DirectX

[modifier] Langage C ou C++ avant tout

Vous pouvez développer pour DirectX avec tout langage capable d'appeler les API de DirectX. C'est le cas par exemple des langages C, C++, C# et Visual Basic .NET. Il en existe surement d'autres.

L'outil de développement à utiliser est à votre libre convenance à partir du moment où est il est en mesure de lier des .lib donnés avec DirectX. L'outil sans conteste le plus adapté pour cela est l'éditeur de liens de Microsoft que l'on retrouve dans sa suite de développement Microsoft Visual Studio .NET. A vous de voir ensuite l'outil que vous êtes en mesure d'utiliser en fonction de vos besoins et de votre budget.

Sachez également que Microsoft propose maintenant le compilateur et l'éditeur de liens (sans l'EDI) gratuitement en téléchargement: Visual Studio Express Editions. Si vous devez utiliser ce toolkit, vous devrez télécharger le Platform SDK de Microsoft qui pèse environ 180Mo (uniquement pour le Core SDK nécessaire).

[modifier] Component Object Model

DirectX repose sur COM ou Component Object Model. C'est une technologie qui permet à un objet de proposer à l'utilisation certaines de ses fonctionnalités à qui veut les utiliser. Voici la définition que donne Microsoft de COM:

COM est le "modèle d'objet" de base sur lequel reposent les contrôles ActiveX et OLE. Ce modèle permet à un objet d'exposer ses fonctionnalités à d'autres composants et d'héberger des applications. Il définit le mode d'exposition de l'objet et la façon dont cette exposition fonctionne dans les processus et en réseau. En outre, COM définit le cycle de vie de l'objet.

COM a des avantages indéniables dont celui de la compatibilité ascendante. Comment un jeu pourrait encore fonctionner sur les nouvelles versions de DirectX si une telle compatibilité n'existait pas ? Si un jeu était développé pour la version 5 de DirectX est-ce qu'il faudrait que je joueur installe cette version devenue obsolète sur son PC ? Heureusement non car la dernière version de DirectX intègre toutes les versions précédentes de DirectX avec des points d'entrée différents.

Comme dans toute conception objet, un objet COM doit être instancié avant de pouvoir être utilisé. Voici à quoi ressemble l'instanciation d'un objet COM en langage C sous Windows:

// Création d'une instance COM de DirectDraw7
LPDIRECTDRAW7 lpDD7 = NULL;
GUID *lpDevice = NULL;
CoInitialize(NULL);
if (FAILED(CoCreateInstance(CLSID_DirectDraw7, NULL, CLSCTX_ALL, IID_IDirectDraw7, (LPVOID *)&lpDD7))) {
   CoUninitialize();
   return(FALSE);
}
if (FAILED(lpDD7->Initialize(lpDevice))) {
   CoUninitialize();
   return(FALSE);
}
 
// Boucle de messages principale :
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
}
 
CoUninitialize();

L'appel à la fonction CoInitialize() permet d'initialiser la librairie COM. Son appel est obligatoire avant tout usage de COM. Vous pouvez également remarquer après la boucle des messages que nous appelons CoUninitialize(). Ce dernier appel permet quant-à lui la fermeture de la librairie COM et ainsi, libérer les ressources réservées par cette application.

Vous pouvez vous en douter, l'appel à la fonction CoCreateInstance() permet de créer une instance de l'objet COM dont l'interface est indiquée (IID_IDirectDraw7). Dans ce cas, nous créons une instance de DirectDraw version 7. Reportez-vous à la documentation et aux fichiers d'entête de DirectX pour savoir quelles sont les différentes interfaces disponibles pour les différents composants de DirectX.

DirectX permet de créer des instances beaucoup plus facilement grâce à des fonctions prévues à cet effet. Nous ne nous étendrons donc pas d'avantage sur l'utilisation de COM avec DirectX. Si vous souhaitez vous compliquer la vie, vous pouvez malgré tout instancier vos objets DirectX avec la méthode indiquée ci-dessus.

[modifier] Les énumérations

Dès les premiers développements avec DirectX, vous vous appercevrez qu'il est nécessaire d'énumérer les listes des ressources disponibles. C'est un traitement standard sous Windows pour obtenir par exemple la liste des applications lancées, la listes des polices de caractères, ... On utilise pour cela des fonctions dites callback qui sont appelées par l'API concernée (DirectX, Kernel32, ...)

Lorsqu'avec DirectX vous souhaitez connaitre la liste des périphériques d'entrée disponibles sur l'ordinateur, vous devez utiliser une fonction callback comme ceci:

// Enumère les périphériques d'entrée pour charger la listbox
// Appelé directement ou indirectement depuis le WinMain
LPDIRECTINPUT8 lpDi8 = NULL;
if (FAILED(DirectInput8Create(hInstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (LPVOID *)&lpDi8, NULL))) return(FALSE);
if (FAILED(lpDi8->EnumDevices(DI8DEVCLASS_ALL, EnumDirectInputDevicesCallback, hListBox, DIEDFL_ATTACHEDONLY))) return(FALSE);

La méthode importante ici est EnumDevices qui donne le nom de la fonction servant à charger une ListBox. Voici le code de cette fonction:

// --------------------------------------------------------------------
// Fonction callback d'énumération des périphériques d'entrée et de chargement de la listbox
// --------------------------------------------------------------------
BOOL CALLBACK EnumDirectInputDevicesCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
{
   HWND hListBox = (HWND)pvRef;
   SendMessage(hListBox, LB_ADDSTRING, 0, (LPARAM)lpddi->tszProductName);
   return(DIENUM_CONTINUE);
}

[modifier] Projets de base

Vous trouverez ci-dessous différents projets pour quelques outils de développement C/C++. Ces projets peuvent servir de base pour le développement avec DirectX:

• Squelette-Visual C Toolkit 2003 C
• Squelette-Visual Studio .NET 2003 C

[modifier] Historique de l'article

Cet article, réalisé par Stéphane VANPOPERYNGHE, a été publié pour la première fois le 13 janvier 2005 sur le site ToutProgrammer.com (1^ème version).