Dernière modif : 25/01/2002

1) Introduction sur la palette

La palette est un tableau à une dimension, commençant à l'adresse mémoire 0x5000000 (variable PaletteBKG déclarée dans le fichier "GBADraw.h") et contenant 256 éléments de 16 bits. Ces éléments sont les couleurs de la palette.

Pour utiliser la palette, il faut commencer par y charger les 256 couleurs quelle devra contenir. Les images affichées dans ce Mode, ne pourront afficher que les 256 couleurs contenues dans la palette.

2) Utilisation de la mémoire vidéo dans ce mode

Comme pour le Mode 3, on peut considérer la mémoire vidéo comme un tableau à une dimension commençant à l'adresse mémoire 0x6000000 (variable VideoBuffer déclarée dans notre fichier "GBADraw.h"). La différence est qu'un pixel n'utilise qu'un seul octet au lieu de deux. Cet octet contient le numéro d'index dans la palette de la couleur à afficher.

La conséquence est qu'une image occupera moitié moins de place en mémoire vidéo que si elle était affichée en Mode 3. De ce fait, on peut placer simultanément deux images en mémoire vidéo: une à partir de l'adresse 0x6000000 (aussi déclaré comme variable VideoFrontBuffer dans le fichier "GBADraw.h") et l'autre à partir de l'adresse 0x600A000 (variable VideoBackBuffer déclarée dans le fichier "GBADraw.h"). L'intérêt de celà, est que l'on peut manipuler une image en mémoire pendant que l'autre est affichée à l'écran, ce qui procure un gain de vitesse d'exécution du programme. Cette méthode s'appelle le "Double Buffering".

NOTE IMPORTANTE: Bien que dans ce Mode, les pixels n'utilisent qu'un seul octet, on ne peut accéder à la mémoire vidéo qu'en 16 bits!!! Ceci étant dû aux limitations "Hard" de la GBA. Ce qui veut dire que pour écrire un seul pixel en mémoire vidéo: il faudra lire deux pixels en mémoire, masquer le pixel que l'on modifie et renvoyer les deux pixels en mémoire. En général, pour accélérer les choses on écrit/lit deux pixels à la fois.

3) Mise en place des couleurs dans la palette

La structure de la palette est la suivante :

Son fonctionnement est très simple, mais comme toujours le plus simple est de s'appuyer sur un exemple:
nous allons placer du vert (0x03E0) dans la palette à l'index 17 avec différentes méthodes.

Si nous avions eu un tableau de 256 éléments de 16 bits contenant les couleurs de la palette, nous aurions pu les placer directement en utilisant la fonction SetPalette_All de la librairie DirectGBA:
u16 pImg_Palette[256]; // tableau contenant les couleurs de la palette
SetPalette_All( pImg_Palette );

4) Affichage d'un pixel à l'écran

Etant donné que la GBA ne peut accéder à la mémoire vidéo qu'en 16 bits, l'affichage se fait en mémoire comme si l'écran n'avait que 120 colonnes de 2 pixels solidaires.

Exemple :

Affichage de deux pixels limitrophes, un rouge contenu dans la palette à l'index 64 et un vert contenu à l'index 17.

Affichage du pixel Vert

Toutes ces opérations peuvent être automatisées en utilisant la fonction PlotPixel4 de la librairie DirectGBA:
PlotPixel4(5, 3, 17);

Affichage du pixel rouge

La procédure est la même que pour l'affichage du pixel vert à la différence qu'il faut placer l'index de la couleur rouge dans l'octet de poids faible en masquant celui de poids fort:
u16 peek = VideoBuffer[2+3*120]; //emplt mém: lig 3, col 2 (col 4 & 5 à l'écran)
u16 send = (0xFF00 & peek) + 64;
VideoBuffer[2+3*120] = send;

Ici encore ces opérations peuvent remplacées par:
PlotPixel4(4, 3, 64);

Affichage des deux pixels

Le plus rapide est d'envoyer les deux pixels à la fois:
VideoBuffer[2+3*120] = 64 + (17<<8);

Ou plus simplement avec la fonction SendPixels4 de la librairie DirectGBA:
SendPixels4(2, 3, 64 + (17<<8));

5) Mise en oeuvre du Mode 4

Pour activer le Mode 4 sur la GBA, il suffit de placer la valeur 4 dans les bits 0 à 2 du registre DISP_CR. Mais, il faut aussi que le "Background" 2 soit utilisable.
N'oublions pas que dans tous les modes "Bitmaps" il faut que le "Background" 2 soit activé pour permettre l'affichage.

Tout ceci se fait facilement avec la fonction SetVideoMode contenue dans la librairie DirectGBA:
SetVideoMode ( MODE4 | BG2 );

6) Exemple n°4 : Remplissage de l'écran

Dans cet exemple n°4, nous allons afficher pixel par pixel un dégradé de Bleu à l'écran.

Le listing est le suivant:

/********************************************************
*	
* Exemple n°4 : Remplissage de l'ecran Mode 4
* Affichage d'un degrade de bleu 
*
* Cree le : 20.08.2001
* Par : Edorul (edorul@caramail.com)
*
* Ver. : 1.0
* Modifié le 
*
********************************************************/

#include "..\DirectGBA\DirectGBA.h"

// Remplissage des 64 premiers indexs de la palette avec le degrade de bleu
void RemplPalette()
{
    u16 i;

    for(i=0; i<32; i++) {
        SetPaletteBKG_Entry(i, RGB(0, 0, i)); //index 0 a 31:du noir au bleu
        SetPaletteBKG_Entry(i+32, RGB(i, i, 31)); //index 32 a 63:du bleu au blanc
    }
}
       
// Remplissage de l'ecran avec degrade de bleu (Pixel par Pixel)
void RemplEcran()
{
    u16 i, j;

    for (i=0; i<240; i++) //colonne
        for (j=0; j<160; j++) //ligne 
            // Affichage du pixel (i, j) avec une teinte de bleu
            PlotPixel4(i,j,(i*64)/240);
}

void AgbMain(void)
{
    //Mise en place des couleurs dans la palette
    RemplPalette();

    //Mise en place des pixels en memoire video
    RemplEcran(); 

    //activation du Mode 4 et donc affichage
    SetVideoMode(MODE4 | BG2 ); 

    while(1) {
    }
}

7) Affichage d'une image à l'écran

• Lancer BMP2GBAX

• Ouvrir "Pastel256.bmp" en cliquant sur Add Bitmap(s) et en retrouvant l'image sur le disque dur.

• Sélectionner Preset 5 (bitmapped, palettized: 256/1), c'est l'option qui permet de convertir l'image pour quelle puisse être utilisée par le Mode 4.

• Cocher l'option Export palette (if any) to <filename>.pal, c'est l'option qui permet de créer un fichier, avec comme extension ".PAL", qui contiendra l'ensemble des couleurs de la palette.

• Cliquer sur Process et choisir un répertoire de destination et un nom pour son fichier binaire, par exemple "Pastel-8b.raw"

• Le fichier binaire "Pastel-8b.raw" et le fichier de palette "Pastel-8b.pal" sont créés. On peut alors quitter BMP2GBAX

;
; Surtout garder les tabulations, ne pas les supprimer
; sinon le compilateur assembleur "zarmasm" risque de 
; faire des erreurs de compilation.
;

	AREA bin_data, DATA, READONLY

		EXPORT Image_Bkg
		EXPORT Palette_Bkg

Image_Bkg
	INCBIN Pastel-8b.raw
Palette_Bkg
	INCBIN Pastel-8b.pal

	END

• Pour transformer notre fichier "Pastel-8b.raw" en un fichier ".H" en allant dans le menu Démarrer | Exécuter de Windows et taper la ligne suivante:
  B2X -c -s -t const_u16 -n Image_Bkg <Pastel-8b.raw> Image.h
  (pour la signification de cette ligne de commande voir le paragraphe VI.6.d-Utilisation du fichier binaire à l'aide d'un fichier d'en-tête).

8) Exemple n°5 : Affichage d'une image

Cet exemple ne fait qu'afficher à l'écran un pastel de Jackie Simmonds nommé "Marche de Pollenca, Mojorque" en 256 couleurs. Pour celà nous utilisons la fonction DrawImg4 de DirectGBA qui affiche directement la totalité de l'image.

"main.c" :

/********************************************************
*	
* Exemple n°5 : Affichage d'une image en Mode 4
* (Pastel de Jackie Simmonds "Marche de Pollenca, Mojorque") 
*
* Cree le : 26.08.2001
* Par : Edorul (edorul@caramail.com)
*
* Ver. : 1.0
* Modifié le 
*
********************************************************/

#include "..\DirectGBA\DirectGBA.h"

extern u16 Palette_Bkg; //variable declaree dans "inc_bins.asm"
extern u16 Image_Bkg; //variable declaree dans "inc_bins.asm"

// Remplissage de tous les index de la palette avec les couleurs de l'image
void RemplPalette()
{
    SetPaletteBKG_All(&Palette_Bkg); //index 0 a 255
}
       
// Remplissage de l'ecran avec l'image
void RemplEcran()
{
    DrawImg4(&Image_Bkg);
}

void AgbMain(void)
{
    //Mise en place des couleurs dans la palette
    RemplPalette();

    //Mise en place des pixels en memoire video
    RemplEcran(); 

    //activation du Mode 4 et donc affichage
    SetVideoMode(MODE4 | BG2 ); 

    while(1) {
    }
}

9) Utilisation du "Double-Buffering"

Comme nous avons vu précédemment, la mémoire vidéo offre suffisament de place, dans ce mode, pour y stocker 2 images à la fois. On peut, donc, manipuler une image en mémoire pendant que l'autre est affichée à l'écran, ce qui procure une gain de vitesse lors de l'exécution du programme.

Les questions qui se posent maintenant sont où placer ces 2 images et comment passer de l'une à l'autre?

a- Où placer les images ?

Il existe deux emplacements ("Buffers") en mémoire vidéo pour y placer les images:

b- Comment passer de l'une à l'autre ?

Pour passer d'une image à l'autre, il faut modifier le bit BACKBUFFER du registre DISP_CR :

Pour permuter les deux images il est recommandé d'attendre la "Synchro-Verticale" (l'instant où l'affichage passe du bas au haut de l'écran) ce qui évite de désagréables effets de clignotement de l'affichage.

c- Attente de la Synchro-Verticale (V-BLANK)

La ligne en cours d'affichage est en permanence indiquée par le registre DISP_Y, situé à l'adresse 0x4000006.
Il suffit alors de lire ce registre et d'attendre que la totalité des lignes soient affichées, c'est à dire que la valeur de DISP_Y soit égale à 160 (les lignes de l'écran qui sont réellement affichées sont numérotées de 0 à 159).

Dans le fichier "GBADraw.h", nous avons la fonction WaitVBLANK qui réalise celà :

#define DISP_Y			*(volatile u16*)0x4000004

void WaitVBLANK(){
	while(DISP_Y < 160){}
}

void Flip(){
	WaitVBLANK();
	if (DISP_CR & BACKBUFFER){
		DISP_CR &= ~BACKBUFFER;
		VideoBuffer = VideoBackBuffer;
	}
	else {
		DISP_CR |= BACKBUFFER;
		VideoBuffer = VideoFrontBuffer;
	}
}