Programmation de la Game Boy Advance : notre premier programme

La GameBoy Advance marque une évolution majeure de la vieillsante GameBoy. Auparavant nantie d'un processeur Z80 et d'un écran LCD de 160 pixels par 140, le nouveau modèle de la plus vendue des consoles de poche propose un matériel bien plus intéressant. Premièrement, la GBA s'avère compatible avec la gamme de jeux GameBoy et GameBoy Color par l'entremise d'un Z80 au coeur de la machine. Le processeur en charge des nouvelles capacités ne se veut autre qu'un ARM/Thumb (ARM7TDMI) cadencé à 16 Mhz. Ce processeur a la particularité de pouvoir fonctionner en mode 32 bits (ARM) ou 16 bits (Thumb). Bien que le mode ARM se trouve plus rapide que le mode Thumb, ce dernier se voit souvent employé en raison de la compacité du code généré. De plus, l'écran se voit maintenant constitué de 240 pixels par 160.

Le développement d'applications pour une GameBoy Advance nécessite bien entendu un compilateur permettant de réaliser une compilation croisée. Deux compilateurs s'avèrent utilisables pour un tel objectif. Le premier appartient à l'ARM Software Development Kit (ou ARM SDT). Une version d'évaluation limitée à 60 jours peut se voir téléchargée sur Internet. Sa faiblesse majeure tient dans son prix exorbitant. Heureusement, les logiciels libres répondent à l'appel en offrant l'incontournable GCC. Vous trouverez en bas de cette page une version de GCC pour ARM modifiée afin de faciliter le développement pour GBA. Les modifications introduites concernent la phase de link qui fait dorénavant appel à des scripts spécifiques pour la GBA. Des versions Linux et Windows vous sont proposées. Le chapitre suivant expose brièvement la procédure d'installation.

La mise à l'essai de vos programmes demande bien entendu de lex exécuter. Pour cela deux solutions s'offrent à vous. La première, la plus simple et la moins coûteuse, concerne l'utilisation d'émulateurs. Quelques-uns se trouvent sur le CD-Rom. La seconde consiste en l'acquisition d'un lecteur de cartouches Flash spécifiques à la GBA. Le distributeur Lik Sang (www.lik-sang.com) propose de tels outils. Un lecteur accompagné d'une cartouche vierge de 256 Mbits coûte environ 200 $. Toutefois, vous serez en mesure d'essayer vos créations directement sur votre GameBoy Advance. Un outil similaire incarné par un câble de communication directe entre la GBA et le PC est également disponible. Son coût bien plus faible (40 $) pourra en intéresser plus d'un.

Le DevKitAdv de Jason Wilkins propose la version 3.0 de GCC pour processeurs ARM. L'installation du kit ne vous posera aucun problème d'ordre technique. Malheureusement, vous aurez sans doute quelques réticences à procéder à l'opération. Ce kit de développment se trouve en effet prévu pour être installé à la racine du système de fichiers. Vous devez donc simplement décompresser toutes les archives directement à la racine. Les utilisateurs de Linux obtiendront donc le répertoire /devkitadv tandis que les utilisateurs de Windows récupéreront le répertoire C:\devkitadv. S'il s'avère théoriquement possible de placer le kit en un autre point du disque, cela reste déconseillé. Vous pouvez néanmoins vous référer aux readmes pour de plus amples informations sur le sujet. Ceci fait, vous n'aurez plus qu'à rajouter les répertoires /devkitadv et /devkitadv/bin à la variable d'environnement PATH.

Le processus de compilation ne demande que relativement peu de travail. L'exemple de ce mois-ci s'accompagne d'un Makefile générique qui pourra se voir employé sous Linux ou sous Windows. Vous constaterez que seules quelques options de GCC supplémentaires différencient une telle compilation d'une compilation classique.

Nous allons commencer par créer un petit programme capable d'afficher des dégradés de couleur à l'écran. Si la GBA possède un écran de type LCD, nous devons savoir que sa manipulation fonctionne à l'instar d'un écran CRT. Nous verrons par la suite que nous devrons notamment tenir compte du rafraîchissement de l'écran. En programmaiton GameBoy Advance, nous nous trouvons très proche du matériel. De ce fait, l'affichage d'un pixel à l'écran correspond à un adressage direct en mémoire. L'adresse de l'écran correspond au nombre 0x6000000. La première étape de notre travail va donc consister à créer une variable simplifiant l'accès à l'écran :

u16* ecran = (u16*) 0x6000000;

Le type de données u16 correspond au type unsigned short. Les types unsigned se trouvant constamment employés, nous avons défini dans notre programme les types u8, u16 et u32 pour désigner les types unsigned char, short et long/int. Essayons à présent d'afficher un pixel de couleur rouge en haut à gauche de l'écran. Nous devons au préalable comprendre comment fonctionne l'écran de la GBA. Cette console offre en effet plusieurs modes graphiques. Nous avons à notre disposition les modes 0, 1, 2, 3, 4, 5 et 7. Oui, nous parlons ici du fameux mode 7 de la Super Nintendo. Chacun de ces modes possède des particularités les rendant indispensables en certaines circonstantes. L'affichage d'une image en plein écran sera ainsi facilité par l'emploi du mode 4. Pour commencer, nous allons employer le mode 3.

Le mode 3 désigne un mode graphique donnant accès à un écran virtuel de 240 pixels par 160. La profondeur de couleurs prend place sur 16 bits. Néanmoins, le bit de poids fort reste inusité. Ainsi, une couleur se verra finalement encodée sur 15 bits. Les 5 premiers bits de poids faible codent la composante rouge de la couleur, les 5 suivants pour le vert et les 5 derniers pour le bleu. Chaque composante se code sur bits et peut donc prendre 32 valeurs possibles. Au final, le mode 3 permet d'afficher 32x32x32 = 32 765 couleurs différentes. Pour faciliter nos manipulations concernant les couleurs, créons une macro intitulée RGB qui calculera le composé rouge/vert/bleu :

#define RGB(r, g, b) (r | (g << 5) | (b << 10))

Essayons maintenant d'afficher notre pixel rouge :

int main()
{
  ecran[0] = RGB(32, 0, 0);
  return 0;
}

Après compilation et execution sur un émulateur nous constatons qu'il ne se passe absolument rien ! Nous devons en effet spécifier au matériel que nous allons utiliser le mode 3. Pour cela, un registre doit se voir modifié. L'adresse de ce registre se révèle l'adresse 0x4000000, ce qui nous amène à la création de la variable globale suivante :

u32* mode  = (u32*) 0x4000000;

La mise en place du mode 3 ne demande que l'exécution de l'instruction *mode = 0x3. Toutefois, cela ne suffit toujours pas. La GBA possède un système de couches graphiques. Nous pouvons utiliser jusqu'à 4 couches graphiques, appelées "background". Avant de dessiner en mode 3 sur l'écran, nous devons activer au moins l'une de ces couches. En l'occurrence la couche 2 : *mode = 0x3 | 0x400. Nous pouvons enfin afficher nos pixels.

Le code source d'exemple disponible en bas de cette page réalise le dessin de plusieurs dégradés de couleurs en mode 3. Le code source contient des commentaires et fait appel à des définitions pour en améliorer la lisibilité. Nous aborderons dans le prochain cours l'affichage d'une image en 256 couleurs par l'entremise du mode 4. Ce mode, contrairement au mode 3, emploie une palette de couleurs mais son utilisation reste très proche du mode 3.

• main.cpp : Le code source du programme présenté dans ce cours.
• WindowsPack.zip : tout ce qu'il faut pour programmer sous Windows. (12,9 Mo)

Version PDF de l'article (152 Ko).

Liens :

• Sommaire
• Partie suivante (Le mode 4)