Partie 2 : Initialisation du mode graphique et affichage de texte
Date de publication : 09/01/2006
Par
KAISER Edouard (kaiser.edouard.free.fr)
Cet article a pour but de vous expliquer comment initialiser le mode graphique
(Plein écran, fenêtré, résolution etc...) et d'utiliser Allegro afin d'afficher du texte.
I. Initialisation du mode graphique
II. Affichage de texte
II-A. Mode graphique
II-A-1. La variable screen
II-A-2. Notion de Font
II-A-3. Fonctions d'affichage
II-B. Mode Texte
III. Programme de démonstration
IV. Conclusion
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...).
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 | #include <allegro.h>
#define HAUTEUR 480
#define LARGEUR 640
int main(void)
{
int i = 10;
int j = 20;
if(allegro_init() != 0)
{
allegro_message(allegro_error);
return EXIT_FAILURE;
}
install_keyboard();
if(set_gfx_mode(GFX_AUTODETECT_WINDOWED,LARGEUR,HAUTEUR,0,0) != 0)
{
allegro_message(allegro_error);
return EXIT_FAILURE;
}
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);
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.
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).
 
|
