Section courante

A propos

Section administrative du site

Utilisation de DirectDraw

DirectDraw (DD), avec son cousin Direct3D (D3D), est la composante visible de DirectX. C'est généralement la première composante que les débutants apprennent à utiliser dans DirectX. DD a une fonction principale : vous permettre de contrôler votre matériel vidéo, ce qui est impossible sous Windows. Ou, du moins, vous ne pourriez pas le contrôler efficacement ni avec de bonnes performances.

Ce page vous permettra de vous familiariser avec la composante de DirectDraw contrôlant les ressources d'affichage : l'interface IDirectDraw7.

Création de l'objet IDirectDraw7

Toutes les interfaces DirectX sont utilisées via des pointeurs, et chaque objet possède un pointeur de type spécifique permettant de communiquer avec son interface. Dans le cas d'IDirectDraw7, ce type de pointeur est LPDIRECT-DRAW7. Dans un jeu ou une application, un seul de ces types est nécessaire (sauf si vous disposez d'un système multi-écrans, auquel cas vous pouvez en utiliser deux ou plus, mais les systèmes multi-écrans dépassent le cadre de cette page).

Par conséquent, lorsque vous utilisez DD, déclarez toujours une variable globale pointant vers une interface IDirectDraw7 :

  1. /* Pointeur IDirectDraw7 */
  2. LPDIRECTDRAW7 lpdd=NULL;

Et quelque part au début de votre initialisation (Prog_Init), créez votre objet en utilisant DirectDrawCreateEx :

  1. HRESULT WINAPI DirectDrawCreateEx(
  2.  GUID FAR *lpGUID,
  3.  LPVOID *lplpDD,
  4.  REFIID iid,
  5.  IUnknown FAR *pUnkOuter
  6. );

Cette fonction renvoie un HRESULT, étant une constante DD_OK ou DDERR_*. Les paramètres sont expliqués dans le tableau suivant :

Paramètre DirectDrawCreateEx Objectif
lpGUID Un pointeur vers un GUID (identifiant unique global) qui identifie les pilotes d'affichage à utiliser avec l'objet IDirectDraw7.
lplpDD Un pointeur vers votre pointeur vers une interface IDirectDraw7. Doit être typé en void**.
iid Identifiant de type d'objet. Doit être défini sur IID_IDirectDraw7.
pUnkOuter Agrégation COM. Utiliser NULL.

Ces paramètres sont assez complexes, il est donc nécessaire de vous donner quelques explications. Un GUID (identifiant unique global) permet à Windows d'identifier tout. Votre carte vidéo en possède un, tout comme la plupart des autres composants matériels de votre machine. Un GUID permet d'identifier n'importe quel composant matériel grâce à un mécanisme de numérotation simple (enfin, pas vraiment simple). Vous n'aurez pas grand-chose à faire avec les GUID, et vous passerez NULL lorsqu'ils vous seront demandés.

Le paramètre iid a une fonction similaire à un GUID : c'est un identifiant de classe. Chaque objet COM (IDirectDraw7 inclus) possède un identifiant de classe ; pour les utiliser, vous devez avoir lié dxguid.lib à votre projet sous l'onglet Projet, Paramètres.

Laissez nous vous montrer le code de création de votre objet IDirectDraw7 :

  1. /* créer l'interface de dessin direct */
  2. HRESULT hr=DirectDrawCreateEx(NULL,(void**)&lpdd,IID_IDirectDraw7,NULL);

Habituellement, la règle est la suivante : si vous ne savez pas à quoi sert le paramètre ou quelle devrait être sa valeur, passez un NULL.

À propos de HRESULT

Généralement, lorsqu'un appel de fonction aboutit et réussit, la valeur DD_OK est obtenue. En cas d'échec, l'une des nombreuses constantes DDERR_* est obtenue, indiquant l'échec et la raison de l'échec. Pour tester cette condition, Microsoft a fourni une macro appelée FAILED. Pour vérifier les erreurs, procédez comme suit :

  1. /* Erreur de vérification */
  2. if(FAILED(hr)) {
  3.    /* il y a eu une erreur */
  4. }

Définition du niveau coopératif

Après avoir créé votre objet IDirectDraw7, vous devez spécifier son mode d'utilisation. Deux options s'offrent à vous : fenêtré et plein écran.

Sélectionnez le mode d'utilisation d'IdirectDraw7 grâce à la fonction membre SetCooperativeLevel :

  1. HRESULT SetCooperativeLevel(
  2.  HWND hWnd,
  3.  DWORD dwFlags
  4. );

Comme toutes les autres fonctions DirectX, cette fonction renvoie une erreur ou une réussite dans un HRESULT. Les paramètres sont expliqués dans le tableau suivant :

Paramètre SetCooperativeLevel Objectif
hWnd La fenêtre de niveau supérieur que DirectDraw doit utiliser.
dwFlags Drapeaux de coopération

Il n'existe qu'une poignée d'options que vous utiliserez fréquemment. Elles sont répertoriées dans le tableau suivant (La plupart des autres options concernent les systèmes multi-écrans et Direct3D) :

Indicateur SetCooperativeLevel Signification
DDSCL_ALLOWREBOOT Permet à un utilisateur final d'utiliser Ctrl+Alt+Delete pendant une application plein écran. C'est indispensable si vous avez l'intention de créer des jeux compatibles Windows.
DDSCL_EXCLUSIVE Spécifie que vous souhaitez un contrôle exclusif sur le matériel d'affichage. Vous devez également utiliser DDSCL_FULLSCREEN.
DDSCL_FULLSCREEN Indique que vous souhaitez une application plein écran. Doit être utilisé avec DDSCL_EXCLUSIVE.
DDSCL_NORMAL Indique que vous créez une application fenêtrée avec DirectDraw. Utile pour le débogage.

La plupart du temps, vous souhaiterez créer des applications exclusives en plein écran, permettant d'utiliser la combinaison de touches Ctrl+Alt+Delete. Le code ressemblera donc à ceci :

  1. /* définir le niveau coopératif-plein écran-exclusif */
  2. hr=lpdd->SetCooperativeLevel(hWndMain,DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT);

Maintenant que vous avez accès au plein écran, vous souhaiterez peut-être modifier le mode d'affichage. Deux options s'offrent à vous : choisir parmi les modes d'affichage courants jusqu'à ce que l'un d'eux fonctionne, ou jusqu'à ce qu'aucun ne fonctionne, auquel cas vous vous retrouverez dans une situation délicate. Ou encore, lister les modes d'affichage disponibles et choisir dans cette liste. Je préfère la deuxième méthode. Les essais et erreurs ne sont pas mon fort.

Énumération des modes d'affichage

L'énumération, quel que soit le type, est un peu déroutante au début. Nous allons simplement regrouper les modes d'affichage dans une liste claire que vous pourrez examiner plus tard dans le code. Commençons par examiner la fonction que vous allez appeler pour effectuer l'énumération, EnumDisplayModes :

  1. HRESULT EnumDisplayModes(
  2.  DWORD dwFlags,
  3.  LPDDSURFACEDESC2 lpDDSurfaceDesc2,
  4.  LPVOID lpContext,
  5.  LPDDENUMMODESCALLBACK2 lpEnumModesCallback
  6. );

Renvoie un HRESULT contenant une indication de réussite ou d'échec. Le tableau suivant détaille la liste des paramètres :

Paramètre EnumDisplayModes Objectif
dwFlags Drapeaux spéciaux indiquant à DD quel type d'énumération vous souhaitez
lpDDSurfaceDesc2 Une description du type de mode d'affichage que vous recherchez
lpContext Une variable de contexte définie par l'utilisateur qui est transmise à la fonction de rappel
lpEnumModesCallback Un pointeur vers la fonction de rappel

Le paramètre dwFlags possède deux valeurs spéciales : DDEDM_REFRESHRATES, qui prend en compte la fréquence de rafraîchissement du mode d'affichage, et DDEDM_STANDARDVGAMODES, énumérant l'ancien mode d'affichage VGA 320x200x8. Vous n'utiliserez aucun de ces indicateurs; la valeur 0 sera toujours passée.

lpDDSurfaceDesc2 est un pointeur vers une structure DDSURFACEDESC2. En définissant certains membres d'une structure DDSURFACEDESC2, puis en appelant l'énumération, vous pourriez filtrer votre recherche. Pour l'instant, vous allez simplement lister tous les modes d'affichage.

Le dernier paramètre, lpEnumModesCallback, est une fonction de rappel définie par l'utilisateur, semblable à celle-ci :

  1. HRESULT WINAPI EnumModesCallback2(
  2.  LPDDSURFACEDESC2 lpDDSurfaceDesc,
  3.  LPVOID lpContext
  4. );

Cette fonction renvoie l'une des deux valeurs suivantes : DDENUMRET_OK pour poursuivre l'énumération, et DDENUMRET_CANCEL pour l'arrêter.

lpDDSurfaceDesc est un autre pointeur vers DDSURFACEDESC2, contenant des informations sur le mode d'affichage énuméré. lpContext contient la valeur initialement transmise lors de l'appel à EnumDisplayModes.

Une structure DDSURFACEDESC2 contient de nombreuses informations. Voici sa définition :

  1. typedef struct _DDSURFACEDESC2 {
  2.  DWORD dwSize;
  3.  DWORD dwFlags;
  4.  DWORD dwHeight;
  5.  DWORD dwWidth;
  6.  union {
  7.   LONG lPitch;
  8.   DWORD dwLinearSize;
  9.  } DUMMYUNIONNAMEN(1);
  10.  DWORD dwBackBufferCount;
  11.  union {
  12.   DWORD dwMipMapCount;
  13.   DWORD dwRefreshRate;
  14.  } DUMMYUNIONNAMEN(2);
  15.  DWORD dwAlphaBitDepth;
  16.  DWORD dwReserved;
  17.  LPVOID lpSurface;
  18.  union {
  19.   DDCOLORKEY ddckCKDestOverlay;
  20.   DWORD dwEmptyFaceColor;
  21.  } DUMMYUNIONNAMEN(3);
  22.  DDCOLORKEY ddckCKDestBlt;
  23.  DDCOLORKEY ddckCKSrcOverlay;
  24.  DDCOLORKEY ddckCKSrcBlt;
  25.  DDPIXELFORMAT ddpfPixelFormat;
  26.  DDSCAPS2 ddsCaps;
  27.  DWORD dwTextureStage;
  28. } DDSURFACEDESC2, FAR* LPDDSURFACEDESC2;    

Comme vous pouvez le constater, les informations ici sont nombreuses, et vous n'en utiliserez qu'une fraction.

Les informations importantes pour un mode d'affichage sont trois éléments : la largeur, la hauteur et la profondeur de couleur. En bref, la profondeur de couleur indique le nombre de bits que contient chaque pixel. Elle a généralement une valeur de 8, 16, 24 ou 32. Au-delà de 8, les bits correspondent à une valeur RVB (rouge, vert, bleu) décrivant une couleur.

Dans DDSURFACEDESC2, vous pouvez voir les membres dwWidth et dwHeight. Ils correspondent à la taille du mode d'affichage (la résolution). Les valeurs courantes sont 640x480, 800x600 et 1024x768. Certaines cartes vidéo peuvent aller encore plus loin, et beaucoup proposent des modes d'affichage plus complexes, comme 400x300, 512x384,...

L'emplacement des bits par pixel n'est pas aussi évident dans la structure DDSURFACEDESC2, car elle fait partie du membre ddpfPixelFormat, lui-même une structure DDPIXELFORMAT.

  1. typedef struct _DDPIXELFORMAT{
  2.  DWORD dwSize;
  3.  DWORD dwFlags;
  4.  DWORD dwFourCC;
  5.  union {
  6.   DWORD dwRGBBitCount;
  7.   DWORD dwYUVBitCount;
  8.   DWORD dwZBufferBitDepth;
  9.   DWORD dwAlphaBitDepth;
  10.   DWORD dwLuminanceBitCount;
  11.   DWORD dwBumpBitCount;
  12.  } DUMMYUNIONNAMEN(1);
  13.  union {
  14.   DWORD dwRBitMask;
  15.   DWORD dwYBitMask;
  16.   DWORD dwStencilBitDepth;
  17.   DWORD dwLuminanceBitMask;
  18.   DWORD dwBumpDuBitMask;
  19.  } DUMMYUNIONNAMEN(2);
  20.  union {
  21.   DWORD dwGBitMask;
  22.   DWORD dwUBitMask;
  23.   DWORD dwZBitMask;
  24.   DWORD dwBumpDvBitMask;
  25.  } DUMMYUNIONNAMEN(3);
  26.  union {
  27.   DWORD dwBBitMask;
  28.   DWORD dwVBitMask;
  29.   DWORD dwStencilBitMask;
  30.   DWORD dwBumpLuminanceBitMask;
  31.  } DUMMYUNIONNAMEN(4);
  32.  union {
  33.   DWORD dwRGBAlphaBitMask;
  34.   DWORD dwYUVAlphaBitMask;
  35.   DWORD dwLuminanceAlphaBitMask;
  36.   DWORD dwRGBZBitMask;
  37.   DWORD dwYUVZBitMask;
  38.  } DUMMYUNIONNAMEN(5);
  39. } DDPIXELFORMAT, FAR* LPDDPIXELFORMAT;

Il s'agit d'une autre structure volumineuse contenant beaucoup d'informations (la plupart sous forme d'unions). Voici votre premier aperçu de DDPIXELFORMAT. Le membre de DDPIXELFORMAT vous intéressant est dwRGBBitCount, contenant la résolution en bits du mode d'affichage.

Commençons donc l'énumération. Deux énumérations : la première compte les modes d'affichage, et la seconde les place dans une liste.

Définissez d'abord une structure contenant toutes les informations applicables à un mode d'affichage (du moins, en ce qui vous concerne) :

  1. struct DisplayMode {
  2.  DWORD dwWidth;
  3.  DWORD dwHeight;
  4.  DWORD dwBPP;
  5. };

Bref et concis, comme il se doit. Ensuite, ajoutez deux variables globales :

  1. /* Le nombre de modes d'affichage sera conservé ici. */
  2. DWORD dwDisplayModeCount=0;
  3. /* Ceci pointera vers la liste des modes d'affichage */
  4. DisplayMode* DisplayModeList=NULL;

La première fonction d'énumération est assez simple, puisqu'elle compte simplement les modes d'affichage :

  1. HRESULT WINAPI EnumModesCallbackCount(
  2.  LPDDSURFACEDESC2 lpDDSurfaceDesc,
  3.  LPVOID lpContext
  4. )
  5. {
  6.  /* incrémenter la variable de comptage */
  7.  dwDisplayModeCount++;
  8.  /* continuer l'énumération */
  9.  return(DDENUMRET_OK);
  10. }

La deuxième énumération n'est pas beaucoup plus difficile :

  1. HRESULT WINAPI EnumModesCallbackList(
  2.  LPDDSURFACEDESC2 lpDDSurfaceDesc,
  3.  LPVOID lpContext
  4. )
  5. {
  6.  /* copier les informations applicables dans la liste */
  7.  DisplayModeList[dwDisplayModeCount].dwWidth=lpDDSurfaceDesc->dwWidth;
  8.  DisplayModeList[dwDisplayModeCount].dwHeight=lpDDSurfaceDesc->dwHeight;
  9.  DisplayModeList[dwDisplayModeCount].dwBPP=lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount;
  10.  /* incrémenter la variable de comptage */
  11.  dwDisplayModeCount++;
  12.  /* continuer l'énumération */
  13.  return(DDENUMRET_OK);
  14. }

Enfin, rassemblez le tout pour que le dénombrement ait lieu :

  1. // effacer le nombre de modes d'affichage
  2. dwDisplayModeCount=0;
  3. // modes d'affichage du nombre
  4. lpdd->EnumDisplayModes(0,NULL,NULL,EnumModesCallbackCount);
  5. // allouer de l'espace à la liste
  6. DisplayModeList=new DisplayMode[dwCount];
  7. // réinitialiser le compte
  8. dwDisplayModeCount=0;
  9. // lister les modes d'affichage
  10. lpdd->EnumDisplayModes(0,NULL, NULL,EnumModesCallbackList);

L'opérateur new remplit à peu près la même fonction que malloc, mais avec une sécurité de type plus élevée. L'équivalent de malloc serait :

  1. DisplayModeList=(DisplayMode*)malloc(sizeof(DisplayMode)*dwDisplayModeCount);    

Lorsque vous avez terminé avec la liste, utilisez le code suivant pour la désallouer :

  1. /* supprimer la liste des modes d'affichage */
  2. delete [] DisplayModeList;
  3. DisplayModeList=NULL;

Cela équivaut à utiliser la fonction free, normalement utilisée avec malloc. Vous disposez désormais de tous les modes d'affichage possibles dans une liste, que vous pouvez parcourir et tester pour trouver le mode souhaité. Vous pouvez également vérifier si un mode donné est pris en charge. Dans le cas contraire, vous pouvez opter pour un mode moins adapté.

Écrivons un code qui vérifie la présence d'un mode 800?600?16 (quasiment disponible).

  1. // Configuration du mode de test
  2. DisplayMode TestMode;
  3. TestMode.dwWidth=800;
  4. TestMode.dwHeight=600;
  5. TestMode.dwBPP=16;
  6. // notre variable de test booléenne
  7. bool found=false;
  8. // notre itérateur
  9. DWORD index;
  10. // où nous l'avons trouvé (tous les bits définis signifient qu'il n'a pas été trouvé)
  11. DWORD foundindex=0xFFFFFFFF;
  12. for(index=0;(index<dwDisplayModeCount) && (!found);index++) {
  13.  if((DisplayModeList[index].dwWidth==TestMode.dwWidth) && (DisplayModeList[index].dwHeight==TestMode.dwHeight) && (DisplayModeList[index].dwBPP==TestMode.dwBPP)) {
  14.   foundindex=index;
  15.   found=true;
  16.  }
  17. }

Vous pourriez effectuer une grande variété de tests sur la liste des modes d'affichage, allant de la recherche du mode le plus grand avec un certain BPP à la recherche du BPP le plus élevé pour un mode donné. Vous pourriez également laisser l'utilisateur final sélectionner le mode d'affichage qu'il souhaite utiliser et enregistrer cette valeur dans un fichier de configuration. Maintenant que vous connaissez les modes disponibles et celui que vous souhaitez, vous pouvez utiliser ces informations pour définir le mode d'affichage. (Difficile de croire que ce sujet ait nécessité plusieurs pages : le code s'exécute en une fraction de seconde.)

Définition du mode d'affichage

Après avoir énuméré les modes d'affichage, le paramétrage est simple. Il se fait avec la fonction membre SetDisplayMode de IDirectDraw7 :

  1. HRESULT SetDisplayMode(
  2.  DWORD dwWidth,
  3.  DWORD dwHeight,
  4.  DWORD dwBPP,
  5.  DWORD dwRefreshRate,
  6.  DWORD dwFlags
  7. );

Cela renvoie à nouveau un HRESULT (vous devriez maintenant repérer un modèle), et les paramètres ressemblent étrangement aux membres de DisplayMode, à l'exception de dwRefreshRate (indifférent, passez donc 0) et dwFlags (indifférent également, passez donc 0). L'appel de cette fonction ressemble généralement à ceci :

  1. // Définir le mode d'affichage
  2. hr=lpdd->SetDisplayMode(800,600,16,0,0);

Bien sûr, les 800, 600 et 16 correspondent au mode d'affichage que vous souhaitez, ou aux variables contenant les valeurs que vous souhaitez.

Récupérer le mode d'affichage actuel

Il peut arriver que vous souhaitiez récupérer le mode d'affichage actuel. Pour cela, utilisez GetDisplayMode.

  1. HRESULT GetDisplayMode(
  2.  LPDDSURFACEDESC2 lpDDSurfaceDesc2
  3. );

Regardez ! Elle renvoie un HRESULT ! (Ce sont toutes des HRESULT et elles sont toutes traitées exactement de la même manière.)

Le seul paramètre de cette fonction est lpDDSurfaceDesc2, étant un pointeur vers une DDSURFACEDESC2. Déclarez une variable de DDSURFACEDESC2, nettoyez-la et appelez la fonction. À son retour, votre DDSURFACEDESC2 contient les informations décrivant le mode d'affichage actuel (de la même manière que lorsque vous avez énuméré les modes d'affichage). Mais qu'entend-on par «nettoyer» une DDSURFACEDESC2 ? Eh bien, dans la plupart des cas, lorsque vous travaillez avec des DDSURFACEDESC2, ou toute autre structure DirectX, vous devez d'abord l'initialiser (mettre tous ses membres à 0) et définir le membre dwSize. Voici comment procéder :

  1. //déclarer la variable
  2. DDSURFACEDESC2 ddsd;
  3. //initialiser à tous les zéros
  4. memset(&ddsd,0,sizeof(DDSURFACEDESC2));
  5. //définir la taille
  6. ddsd.dwSize=sizeof(DDSURFACEDESC2);

Une fois nettoyé, il est prêt à être utilisé :

  1. //récupérer le mode d'affichage
  2. hr=lpdd->GetDisplayMode(&ddsd);

Tout comme dans la fonction d'énumération, la largeur et la hauteur du mode d'affichage sont entreposées dans ddsd.dwWidth et ddsd.dwHeight, et les bits par pixel sont stockés dans ddsd.ddpfPixelFormat.dwRGBBitCount.

Dernière chose : Libérer les objets

Il existe une méthode particulière pour supprimer presque tous les objets DirectX une fois que vous en avez terminé avec eux. Pour votre lpdd, voici à quoi cela ressemble :

  1. if(lpdd) {
  2.  lpdd->Release();
  3.  lpdd=NULL;
  4. }

Ce même extrait, avec une variable différente, sera utilisé pour la majeure partie du nettoyage de DirectX. Tout comme il était important, sous GDI, de supprimer votre objet et vos contrôleurs de domaine, il est également important de supprimer votre objet DirectX.



Dernière mise à jour : Dimanche, le 6 juillet 2025