DirectDraw et GDI

Les fonctions graphiques du GDI restent heureusement disponibles.

(Pour comprendre ce chapitre, il est indispensable de connaître le GDI)

L'ennui, c'est que pour utiliser ces fonctions, vous avez besoin d'avoir un handle sur un contexte de périphériques.

On pourrait être tenté d'utilisé les fonctions classiques du GDI, mais se serait une bien mauvaise idée. Car le but est de dessiner dans les surfaces DirectDraw (qu'elles soient pimaire, secondaire (backbuffer) ou offscreen).

Heureusement, des méthodes sont prévues pour retourner un handle sur contexte de périphériques sur vos surfaces:

HDC hdc

lpDDSSurface->GetDC(&hdc);

Avec lpDDSSurface un pointeur sur une surface...C'est aussi simple que cela !

De là, toutes les fonctions du GDI sont disponibles pour la surface.

Ne pas oublier de faire (tout comme dans le GDI):

lpDDSSurface->ReleaseDC(hdc); dès que les opérations graphiques sont terminées !!!

Utilisation des fonction graphiques GDI sur une surface DirectDraw

Voici un exemple:

Version DirectX 5:Version DirectX 7:Vous constaterez que les différences sont minimes !

Afficher du texte GDI sur une surface

Ici, une fonction affichant du texte, on pourra passer la couleur de fond, la couleur du texte, les positions et bien sûr, le texte !

Pour les fonctions GDI, voir (ou revoir) les fonctions GDI et tout particulièrement les fontes et les remarques sur les fontes.

Le code est pour DirectX5, mais il faut peut de chose pour le convertir en DX7 !

HRESULT DDTextOut( LPDIRECTDRAWSURFACE lpDDSSurface, 
   char* lpString, 
   DWORD BackColor,
   DWORD TextColor,
   int posx,
   int posy)
{ 
   HRESULT ddrval; // Code de retour
   HDC hdc; // device context
   
   // Essayons d'avoir un device context
   ddrval = lpDDSSurface->GetDC( &hdc );
   if SUCCEEDED( ddrval )
   {
   	// Couleur background
   	SetBkColor( hdc, BackColor );
   	// Couleur du text
   	SetTextColor( hdc, TextColor);
   	// Affichage du text au coordonnées posx et posy
   	TextOut( hdc, posx, posy, lpString, lstrlen(lpString) -1 );
   	//Effacement du device context
   	lpDDSSurface->ReleaseDC( hdc );
   }
   return ddrval;
}

Charger une image bitmap sur une surface

Charger un bitmap dans une surface ne sera pas bien compliqué !

L'essentiel du code sera une utilisation simple du GDI. Je ne rentrerai pas dans le détail des fonctions utilisées puisque je l'ai déjà fait dans le chapitre GDI utilisation API: (Je crois que j'insiste beaucoup dans ce chapitre sur ce lien GDI, il faudrait que je me calme !).

Le traitement se déroulera en deux phases:

1er phase

Charger une image Bitmap dans un contexte mémoire et créer une surface offscreen de la taille de l'image:

Vous utiliserez la fonction HBITMAP LoadBitmap( HINSTANCE hInstance, LPCTSTR lpBitmapName); pour charger l'image. (chapitre - Charger un Bitmap (BMP ou DIB), icône ou curseur).

Vous obtenez un handle sur votre image.

Grâce à la fonction qui suit, vous pourrez récupérer les informations sur ce bitmap avec en autre la taille de l'image. (chapitre - Afficher/Traiter des bitmaps dans des contextes de périphériques).

int GetObject( HGDIOBJ hgdiobj, int cbBuffer, LPVOID lpvObject );

Vous allez donc pouvoir nous créer une surface offscreen ayant les caractéristiques de l'image. J'utiliserai dans l'exemple suivant une fonction perso. que vous avez vu lors de la création d'une surface: DDCreateOffScreenSurface().

D'où le code suivant, à convertir éventuellement en DirectX 7

Il faut passer à la fonction un pointeur sur une interface DirectDraw et le nom du fichier bitmap à charger !

IDirectDrawSurface * DDLoadBitmap(IDirectDraw *pdd, LPCSTR szBitmap) { HBITMAP hbm;// handle du bitmap BITMAP bm; // objet bitmap IDirectDrawSurface *pdds; // la surface à créer hbm=(HBITMAP) LoadImage (NULL,szBitmap,IMAGE_BITMAP,0,0,LR_LOADFROMFILE|LR_CREATEDIBSECTION); if (hbm == NULL) return NULL; GetObject(hbm, sizeof(bm), & bm); pdds = DDCreateOffScreenSurface(pdd, bm.bmWidth, bm.bmHeight); if (pdds) DDCopyBitmap(pdds, hbm, bm.bmWidth, bm.bmHeight); DeleteObject(hbm); return pdds; }

2ième phase

Transférer l'image sur une surface offscreen existante. Cette fonction est à part de la précédente car pourra être réutilisée sans avoir forcement besoin de recharger une bitmap, l'image pouvant déjà être en mémoire.

Reste à faire la création d'un contexte de périphérique en mémoire HDC CreateCompatibleDC( HDC hdc); et d'associer l'image à ce contexte SelectObject( hdcImage, hbm ). Classique jusque là.

Sachant qu'il est possible d'avoir un contexte de périphérique mémoire sur une surface DirectDraw, et que vous en avez déjà un pour l'image, vous pourrez utiliser la fonction BitBlt() de Windows API pour transférer l'image.

Ne pas oublier de libérer toutes les ressources et c'est fini !

En entrée, un handle de bitmap et une surface offscreen.

HRESULT DDCopyBitmap(IDirectDrawSurface *pdds, HBITMAP hbm, int dx, int dy)
{
   HDC hdcImage;
   HDC hdc;
   HRESULT hres;
   HBITMAP hbmOld;

   hdcImage = CreateCompatibleDC(NULL);
   hbmOld = (HBITMAP)SelectObject(hdcImage, hbm);

   if ((hres = pdds-> GetDC(& hdc)) == DD_OK)
   {
	   BitBlt(hdc, 0, 0, dx, dy, hdcImage, 0, 0, SRCCOPY);
	   pdds-> ReleaseDC(hdc);
   }

   SelectObject(hdcImage, hbmOld);
   DeleteDC(hdcImage);

   return hr;
}