I. Initialisation du mode graphique

Cette étape est essentielle. Elle détermine le mode d'affichage dans lequel s'exécutera l'application. Afin de configurer le mode graphique, il existe une fonction bien précise :

int set_gfx_mode(int card, int width, int height, int v_width, int v_height);

Grâce à cette fonction nous allons pouvoir définir si nous souhaitons une exécution en plein écran, ou plutôt en mode fenêtré ainsi que la résolution. Cette fonction retourne 0 si tout s'est bien déroulé, dans le cas contraire il s'agira d'un nombre négatif.

Il existe une variable globale : allegro_error qui contient une chaîne de caractère donnant des renseignements sur la dernière erreur survenue. Elle peut s'avérer très utile lors des phases de debugage.

Description des paramètres :

Le paramètre int card est un "index" vers différents modes graphiques. Sa valeur sera généralement une des cinq constantes ci dessous, définies par Allegro. Vous pouvez les trouver dans allegro.h afin de voir à quoi elles correspondent.

  • GFX_AUTODETECT : Laisse Allegro sélectionner le meilleur driver approprié
  • GFX_AUTODETECT_FULLSCREEN : Laisse Allegro sélectionner le meilleur driver pour un affichage plein écran
  • GFX_AUTODETECT_WINDOWED : Idem mais dans un mode fenêtré
  • GFX_TEXT : Ferme tout les modes graphiques précédemment mis en place, permet de travailler dans un mode texte
  • GFX_SAFE : Driver particulier permettant de garantir l'initialisation d'un mode graphique.

Il existe d'autres valeurs, mais ce sont des valeurs spécifiques à certaines plateformes, donc non portable. (Ex : GFX_GDI, spécifique à Windows, qui permet un mode fenêtré garantissant l'exécution au détriment des performances, GFX_DIRECTX_ACCEL, GFX_DIRECTX_SOFT, etc...).

Vous trouverez plus d'informations sur : http://www.talula.demon.co.uk/allegro/onlinedocs/en/allegro.html
section Platform specifics.

Les paramètres int width, int height déterminent respectivement la longueur et la hauteur de la résolution (l'unité est le pixel).

Les deux derniers paramètres (int v_width, int v_height) permettent la mise en place d'un écran virtuel qui est plus grand que celui déterminé par int width, int height. Un écran virtuel permettra d'effectuer un effet de scrolling par exemple. A ce titre, Allegro propose une fonction : int scroll_screen(int x, int y); qui permet de scroller l'écran en précisant les coordonnées (x,y);

Lors de l'initialisation du mode graphique, des macros sont mises en place permettant la récupération de quelques informations.

Description des macros :

  • SCREEN_W : Largeur de l'écran visible
  • SCREEN_H : Hauteur de l'écran visible
  • VIRTUAL_W : Largeur de l'écran virtuel
  • VIRTUAL_H : Hauteur de l'écran virtuel

Il est inutile de donner une valeur aux paramètres d'hauteur et de longueur concernant le mode GFX_TEXT. Il suffira de les mettre à 0, car nous ne travaillons pas en mode graphique.

II. Affichage de texte

On distingue deux façons d'afficher du texte sous Allegro : En mode texte et en mode graphique. Je vais vous présenter ces deux façons, la dernière étant bien évidemment la plus intéressante !

II-A. Mode graphique

Il s'agit du mode le plus utilisé, mais pas forcément le plus facile à utiliser ! =) Cependant Allegro nous fournit un ensemble de fonctions qui nous permettrons d'effectuer rapidement et simplement des affichages à l'écran.

II-A-1. La variable screen

L'initialisation d'un mode graphique, qu'il soit fenêtré ou plein écran, engendre l'initialisation d'une variable globale qui se nomme screen. Pour être précis, cette variable est de type BITMAP*, il s'agit donc d'un pointeur vers une structure de type BITMAP. Pour l'instant, il suffit de retenir que screen est un pointeur vers la mémoire vidéo visible. Tout ce qui est à l'écran, se trouve dans la zone mémoire vidéo pointée par screen. De ce fait cette variable sera souvent sollicitée quand un affichage à l'écran sera souhaité.

II-A-2. Notion de Font

Allegro est capable d'afficher plusieurs polices de caractères. La plus part des fonctions d'affichage de texte en mode graphique prennent un pointeur vers un type FONT en paramètre. Il s'agit d'un pointeur vers une structure qui décrit une police d'affichage. Il existe une variable globale, décrivant une FONT par défaut :

extern FONT *font;

Vous vous doutez donc qu'il existe des fonctions permettant de charger d'autres types de font en mémoire. Peut être même des fonctions permettant de charger une font directement à partir de son fichier .ttf (True Type Font) ? Et bien non ce n'est pas si simple, bien qu'il existe des extensions à Allegro permettant cela (AllegTTF : http://www.deleveld.dds.nl/allegttf.htm).

De quoi est donc capable Allegro ? Et bien Allegro propose des fonctions permettant de charger une font à partir de fichiers GRX, des polices BIOS (.fnt) ou tout simplement un fichier image contenant la liste des caractères avec un pas régulier. Il existe des logiciels comme TTF2PCX (http://www.talula.demon.co.uk/ttf2pcx/index.html) qui exportent vos polices TTF dans un format chargeable par Allegro. Si vous utilisez ce logiciel, télécharger la version 16bits (qui fonctionne sous Windows XP), il semble y avoir quelques soucis avec la version 32bits (chez moi en tout cas). Donc finalement comment faire pour charger une police ? Et bien il existe la fonction :

FONT *load_font(const char *filename, RGB *pal, void *param);

Le premier paramètre est le nom du fichier contenant la police à charger. Si le chargement s'est bien effectué et que la police contient une palette de couleur, cette palette est enregistrée dans le deuxième paramètre. Le dernier paramètre permet de passer des informations au loader de font pour un chargement spécifique. Il s'agit de cas très particulier, nous le positionnerons la plus part du temps à NULL. Pour finir, cette fonction renvoie donc un pointeur vers une FONT, si tout s'est bien passé, sinon elle renverra NULL.

Attention !
Penser à toujours vérifier les valeurs de retour des fonctions ! Tout ne se passe pas forcément bien.

II-A-3. Fonctions d'affichage

On distingue 2 types d'affichage : Les fonctions qui affichent des chaînes non formatées, et celles qui affichent les chaînes formatées !

Fonctions d'affichage de chaînes non formatées :

void textout_ex(BITMAP *bmp, const FONT *f, const char *s, int x, y, int color, int bg);
Cette fonction affiche dans la bitmap bmp avec la fonte f la chaîne de caractères non formatée s à la position x,y et avec la couleur color. Si la couleur est -1 et qu'une fonte colorée est utilisée ce sont les couleurs originales de la fonte qui seront utilisées. bg détermine la couleur du fond sur la partie ou sera affiché le texte.

void textout_centre_ex(BITMAP *bmp, const FONT *f, const char *s, int x, y,int color, int bg);
Idem mais la position x,y indiqué sera considérée comme la position du centre de la chaine à afficher.

void textout_right_ex(BITMAP *bmp, const FONT *f, const char *s, int x, y,int color, int bg);
Idem mais cette fois la chaine sera aligné sur le bord droit de l'écran.

void textout_justify_ex(BITMAP *bmp, const FONT *f, const char *s, int x1, int x2, int y, int diff, int color, int bg);
Affiche le texte entre x1 et x2. Si l'espace délimité par x1 et x2 est plus petit que la taille de la chaine, cette dernière sera alignée sur la gauche de l'écran.

Fonctions d'affichage de chaînes formatées :

void textprintf_ex(BITMAP *bmp, const FONT *f, int x, y,int color, int bg, const char *fmt, ...);
Comme son nom l'indique, c'est une fonction d'affichage de texte dans le style de printf() en C. Elle utilise le même formatage des chaînes de caractères (%d,%s etc...). Cette fonction affiche donc dans la bitmap bmp avec la fonte f, à la position x,y et avec la couleur color la chaîne de caractères formatée fmt. La couleur du fond est désignée par bg.

void textprintf_centre_ex(BITMAP *bmp, const FONT *f, int x, y,int color, int bg, const char *fmt, ...);
Idem mais les coordonnées passées en paramètres sont considérées comme le centre de la chaîne.

void textprintf_right_ex(BITMAP *bmp, const FONT *f, int x, y,int color, int bg, const char *fmt, ...);
Idem mais permet un alignement sur la droite de l'écran.

void textprintf_justify_ex(BITMAP *bmp, const FONT *f, int x1, int x2, int y, int diff, int color, int bg, const char *fmt, ...);
Fonction identique à textout_justify vu ci dessus, mais permet d'utiliser des chaînes formatées comme avec printf en C.

Si Allegro rencontre un caractère à afficher qu'il ne trouve pas dans la FONT, il écrira le caractère se trouvant dans la variable globale extern int allegro_404_char. Il est possible de changer la valeur de cette variable (exemple : allegro_404_char = '*';).

Attention !
Les caractères spéciaux comme \n ne fonctionnent pas avec ces fonctions. Il faudra jouer sur la position d'affichage pour effectuer un passage à la ligne.

Fonctions diverses :

Il est possible de déterminer le mode d'affichage du texte à travers la fonction :

int text_mode(int mode);

Si le paramêtre mode est supérieur ou égal à 0, le texte est opaque et le fond du texte prend la couleur donnée par mode. Si mode est négatif le texte est affiché et le fond est transparent. Par défaut mode est à 0 ce qui donne un fond noir pour le texte.

Il existe d'autres fonctions en rapport avec le texte qui permettent par exemple de récupérer la longueur d'une chaîne en pixel ou bien sa largeur pour une font donnée :

int text_length(const FONT *f, const char *str);
int text_height(const FONT *f);

Pour finir voici une fonction bien pratique permettant de renvoyer une valeur de couleur en lui fournissant les valeurs RGB (Red, Green, Blue) :

int makecol(int r,int g,int b);

II-B. Mode Texte

Contrairement au mode graphique, l'affichage de texte en mode GDI_TEXT s'effectue à travers la fonction :

void allegro_message(const char *msg, ...);

Cette fonction ne doit être utilisée que dans ce mode ou bien avant l'appel d'initialisation d'un mode graphique. Pour les plateformes possédant une console(DOS, Unix etc...) , l'affichage de la chaîne se fera dans la console. Pour les systèmes en mode graphique, l'affichage s'effectuera dans une boite de dialogue. Nous n'avons pas à nous soucier de la position, de la couleur, etc...

Cette fonction est une fonction à paramètres variables. Elle prend en paramètre une chaîne formatée comme la fonction printf en C.

III. Programme de démonstration

Le programme ci dessous est entièrement écris en C et essaie de rester le plus standard possible. Son rôle est d'initialiser Allegro, passer en mode graphique et de montrer les possibilités de l'affichage de texte en mode graphique.

C
Sélectionnez

#include <allegro.h>
 
#define HAUTEUR 480
#define LARGEUR 640
 
int main(void)
{
	/* Variable pour effectuer des demonstrations avec les chaines formatees */
	int i = 10;
	int j = 20;
 
	/* Initialisation d'Allegro */
	if(allegro_init() != 0)
	{
		allegro_message(allegro_error);
		return EXIT_FAILURE;
	}
 
	/*
	   Mis en place du clavier pour la foncion readkey en fin du fichier
	   sinon la fenetre se ferme immediatement et l'on a pas le temps de
	   la visualiser. Ces fonctions seront etudiees au cours d'un tutorial
	   ne vous inquietez pas.
	*/
	install_keyboard(); 
 
	/* Mise en place d'un mode graphique fentetree */
	if(set_gfx_mode(GFX_AUTODETECT_WINDOWED,LARGEUR,HAUTEUR,0,0) != 0)
	{
		allegro_message(allegro_error);
		return EXIT_FAILURE;
	}
 
	/* Affichage chaine formatee & non formatee */
	textout_ex(screen,font,"Allegro facile avec Developpez.com !",100,65,makecol(120,200,255),0);
	textprintf_ex(screen,font,100,85,makecol(255,0,50),0,"Valeur de i : %d",i);
 
	/* On centre au milieu de l'ecran la valeur de j */
	textprintf_centre_ex(screen,font,LARGEUR/2,HAUTEUR/2,makecol(255,255,0),0,"Valeur de j : %d",j);
 
	textout_centre_ex(screen,font,"prochain tutorial : la GUI (Graphic User Interface)",LARGEUR/2,HAUTEUR/2-15,makecol(0,255,0),0);
 
	readkey();
 
	return 0;
} END_OF_MAIN()
					

Vous trouverez ci joint des fichiers .zip contenant respectivement le code sous l'environnement Code::Blocks ainsi que pour Visual Studio 2005.

Code::Blocks
Visual Studio 2005

IV. Conclusion

Dans ce chapitre nous avons vu qu'il était important d'initialiser le mode graphique car c'est ce dernier qui détermine les fonctions d'affichage que nous pourront utiliser. Nous avons également vu qu'il existait deux façons d'afficher du texte sous Allegro : en mode graphique et en mode texte. Dans le prochain tutorial je vous présenterai les fonctions que propose Allegro afin de mettre en place une GUI (Graphic User Interface).