Initiation à l’interface de jeu GAPI

DirectDraw n’est pas disponible pour les développeurs de jeux destinés à la plate-forme Pocket PC. Bonne nouvelle : Microsoft vient de créer une nouvelle API de jeu spécialement conçue pour le Pocket PC. Surnommée "GAPI" (Game Application Programming Interface - Interface de programmation d’applications de jeux), elle permet non seulement d’accéder directement à la mémoire d’affichage, mais aussi aux touches du Pocket PC.

Étape 1 : Créez une application "Hello World"

GAPI n’est pas incluse dans le kit de développement de logiciels (SDK) Pocket PC. Voici quelques étapes préalables :

1. Copiez manuellement le fichier "GX.H" dans le répertoire Include du Kit de développement de logiciels Pocket PC.
2. Copiez le fichier "GX.LIB" dépendant du processeur dans le répertoire Lib correspondant du Kit de développement de logiciels Pocket PC.
3. Enfin, copiez le fichier "GX.DLL" dépendant du processeur dans le répertoire "Windows" de votre Pocket PC.

Vous êtes maintenant prêt à créer votre premier programme simple "Hello World".

1. Lancez eMbedded Visual C++, créez un nouveau projet d’application Pocket PC et nommez-le FirstGX.

Une fois que l’Assistant a terminé de créer la nouvelle application, ajoutez les appels d’initialisation de l’interface GAPI.

1. Ajoutez les lignes de code source suivantes affichées en caractère gras à la fin de la fonction InitInstance.

   UpdateWindow(hWnd);
   
   // Essaie d'ouvrir l'accès plein écran pour l'affichage
   if (GXOpenDisplay(hWnd, GX_FULLSCREEN) == 0) {
    return FALSE; // impossible de dessiner.
   }
   
   // Initialise les touches
   GXOpenInput();
   
   // Extrait les propriétés d'affichage
   g_gxdp = GXGetDisplayProperties();
   // Extrait les informations sur les touches et complète
   // la structure de g_gxkl
   g_gxkl = GXGetDefaultKeys(GX_NORMALKEYS);
   
   return TRUE;
   

Le code utilise deux variables qui doivent être définies dans l’espace global du fichier source FirstGX.cpp. Vous devez également inclure GX.H au code source pour éviter les erreurs de compilation.

1. Ajoutez les lignes suivantes directement en dessous des fichiers include que l’Assistant eMbedded Visual C++ a créés :

   #include "gx.h"
   GXDisplayProperties g_gxdp; // structure GX 
   GXKeyList g_gxkl; // Structure GX
   

Vous devez nettoyer l’interface GAPI avant de quitter l’application.

1. Insérez les deux lignes suivantes à la fin de la fonction WinMain :

   GXCloseDisplay();
   GXCloseInput();
   

Étape 2 : Écriture directe dans la mémoire d’affichage

Avant de passer au codage, un peu de théorie. Selon votre modèle de Pocket PC, vous disposez d’un affichage couleur 16 bits (Casio, HP ou Compaq) ou d’un affichage 8 bits (noir et blanc ou couleur, comme le Compaq Aero 1550). Pour déterminer le type d’affichage de votre Pocket PC, vous pouvez évaluer le membre cBPP de l’enregistrement g_gxdp. Vous saurez ainsi le nombre de bits dont vous disposez.

Avant d’accéder directement à la mémoire d’affichage des écrans 16 bits, vous devez savoir comment le contrôleur d’affichage interprète le masque de couleurs 16 bits. Il existe deux indicateurs possibles : KfDirect555 et kfDirect565. Le 555 effectue une conversion vers le masque de couleurs XRRRRRVV.VVVBBBBB (pour Rouge-Vert-Bleu), tandis que le 565 convertit en RRRRRXVV.VVVBBBBB.

Sur les périphériques couleur 8 bits, vous pouvez utiliser un octet pour adresser les 256 couleurs.

Vous êtes maintenant prêt à écrire à l’écran. Nous voulons remplir la totalité de l’écran avec une couleur lorsque l’utilisateur appuie sur l’une des touches.

1. Ajoutez la fonction suivante au début du fichier source de FirstGX.cpp.

bool ClearScreen(int colRed,int colGreen, int colBlue)
{
 // 16 bits par code pixel. Notez les 2 formats de pixels différents.
 switch (g_gxdp.cBPP)
 {
 case 16: {
 unsigned short PixelCol = 0;
 if (g_gxdp.ffFormat | kfDirect565) {
 PixelCol = (unsigned short)
 ((colRed & 0xff)<< 11 |
 (colGreen & 0xff) << 5 |
 (colBlue & 0xff));
 } else if (g_gxdp.ffFormat | kfDirect555) {
 PixelCol = (unsigned short)
 ((colRed & 0xff)<< 10 |
 (colGreen & 0xff) << 5 |
 (colBlue & 0xff));
 }

 unsigned short * pusLine = (unsigned short *)GXBeginDraw();
 if (pusLine == NULL) return false; // DESSIN IMPOSSIBLE

 for (unsigned int y = 0; y 
< g_gxdp.cyHeight; y++) {
 unsigned short * pusDest = pusLine;
 for (unsigned int x = 0;
 x < g_gxdp.cxWidth; x++) {
 *pusDest = PixelCol;
 pusDest += g_gxdp.cbxPitch >> 1;
 }
 pusLine += g_gxdp.cbyPitch >> 1;
 }
 GXEndDraw();
 break;
 }
 case 8: {
 // Obtenir une couleur aléatoire
 // IMPORTANT:
 // 8 bits utilisent une palette et le formulaire
 // ci-dessous ne calcule pas une couleur en lecture RVB
 unsigned char bPixel = (colRed &0xf)<<5 |
 (colGreen&0x3)<<3 |
 (colBlue&0xF);

 unsigned char * pbLine = (unsigned char *)GXBeginDraw();
 if (pbLine == NULL) return false;// DESSIN IMPOSSIBLE

 for (unsigned int y = 0; y 
< g_gxdp.cyHeight; y++) {
 unsigned char * pbDest = pbLine;
 for (unsigned int x = 0;
 x < g_gxdp.cxWidth; x++) {
 *pbDest = bPixel;
 pbDest += g_gxdp.cbxPitch;
 }
 pbLine += g_gxdp.cbyPitch;
 }
 GXEndDraw();
 break;
 }
 }
 return false;
}

Étape 3 : Accès aux touches

C’est la tâche la plus simple de toutes. Tout le monde connaît les messages WM_messages de Windows et la façon de les utiliser. Cette connaissance vous permet d’utiliser les touches de votre Pocket PC. Il suffit d’analyser le message WM_KEYUP ou WM_KEYDOWN dans votre procédure Windows.
Voici la branche WM_KEYDOWN de notre première application FirstGX :

case WM_KEYDOWN:
 vkKey = (short)wParam;
 if (vkKey == g_gxkl.vkUp) {
 ClearScreen(0,0,0); // Noir
 break;
 }

 if (vkKey == g_gxkl.vkDown) {
 ClearScreen(255,0,0); // Rouge
 break;
 }

 if (vkKey == g_gxkl.vkLeft) {
 ClearScreen(255,0,0); // Vert
 break;
 }

 if (vkKey == g_gxkl.vkRight) {
 ClearScreen(0,0,255); // Bleu
 break;
 }

 if (vkKey == g_gxkl.vkStart) {
 SendMessage(hWnd, WM_CLOSE, 0, 0);
 break;
 }

La liste des noms de touche possibles se trouve dans la définition de structure GXKeyList située dans le fichier include gx.h.

Étape 3 : Prêt au lancement !

Avant de pouvoir compiler et télécharger votre nouvelle application FirstGX sur le Pocket PC, vous devez ajouter gx.lib à la liste des bibliothèques de votre projet. Compilez maintenant votre première GAPI, téléchargez-la sur votre Pocket PC et jouez avec les touches pour voir ce qui se passe.

Dernière mise à jour le mercredi 27 septembre 2000