Partie 1 : Installation, configuration et premier programme

KAISER Edouard

Cet article a pour but de vous expliquer comment installer Allegro sous deux principaux IDE ainsi que sa configuration. Pour terminer, un premier programme sera implémenté.

- Titre : Partie 1 : Installation, configuration et premier programme

- Auteur : KAISER Edouard

- Parution : 5 décembre 2005

- Mise à jour : 3 janvier 2006

- Licence : Copyright ® 2005 KAISER Edouard. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Description d'Allegro

- II. Installation d'Allegro

- II-A. Installation sous Dev-C++ (Bloodshed)

- II-B. Installation sous Visual Studio

- II-C. Installation sous Code::Blocks

- III. Configuration & Premier programme

- III-A. Configuration sous Dev-C++

- III-A-1. Linkage statique

- III-A-2. Linkage dynamique

- III-B. Configuration sous Visual Studio

- III-B-1. Linkage statique

- III-B-2. Linkage dynamique

- III-C. Configuration sous Code::Blocks

- III-C-1. Linkage statique

- III-C-2. Linkage dynamique

- III-D. Premier programme

I - Description d'Allegro

Allegro est un acronyme récursif qui correspond à "Allegro Low LEvel Game ROutines" (routines de bas niveau pour les jeux).

Il s'agit donc d'une API destinée au développement de jeux vidéos dans les langages C/C++. Cette API, distribuée gratuitement, supporte de nombreuses plateformes telles que des Unix (Linux, FreeBSD, Irix, Solaris Darwin), BeOS, MacOS X, Windows bien évidemment, et notre bon vieux DOS.

Allegro propose de nombreuses fonctions graphiques et sonores, gère le clavier, la souris, le joystick et des timers. Cette API dispose également de fonctions mathématiques 3d et en point fixe, de fonctions de gestion de fichiers de données compressés et d'une interface graphique.

Pour les connaisseurs, le moteur de combat 2D " Mugen " fut développé en C à l'aide d'Allegro. Nous allons voir comment installer cette API sous votre IDE préférée.

Il existe plusieurs méthodes pour installer Allegro. Vous pouvez par exemple choisir de compiler l'API pour ensuite l'utiliser ou bien directement télécharger les library compilées et les installer dans votre IDE. Je ne vous indiquerai pas ici la méthode pour compiler Allegro par contre je vous donnerai les informations nécessaires afin d'installer les library pré compilées.

Site web officiel : http://alleg.sourceforge.net/

II - Installation d'Allegro

II-A - Installation sous Dev-C++ (Bloodshed)

Vous trouverez cet IDE gratuit à cette adresse : http://www.bloodshed.net/dev/devcpp.html

Tout d'abord il va falloir télécharger les bibliothèques de fonctions compilées d'Allegro destinées au compilateur de Dev C++ qui est le plus souvent MinGW sous Windows.
Vous trouverez un .zip à cette adresse, section " Binary ", package pour MinGW : http://www.allegro.cc/files/

Une fois l'archive décompressée, vous remarquerez la présence de 3 dossiers : include, bin et lib.
Les fichiers contenus dans le dossier bin sont les DLL que vous devrez placer dans le répertoire system32 de votre dossier système : windows.
Les fichiers et dossiers se trouvant dans le dossier include doivent être copiés dans le dossier include de Dev C++. Il s'agit des header files contenant les signatures des fonctions d'Allegro et autres macros nécessaires au développement d'applications multimédia sous cette API.
Le contenu du dossier lib devra également être copié dans le dossier lib de Dev C++. Ces fichiers sont les bibliothèques contenant le code des fonctions que propose Allegro.

II-B - Installation sous Visual Studio

L'installation d'Allegro sous cet environnement est quasi identique à l'installation sous Dev C++. Cependant les compilateurs sont différents, de ce fait le format des bibliothèques de fonctions va changer. C'est pour cela qu'il faudra télécharger un pack propre à l'environnement Visual Studio.

Vous trouverez à cette adresse une liste d'archives .zip destinées à différentes versions de Visual Studio (de la version 6 jusqu'à la 8) : http://www.allegro.cc/files/

A partir de la, le déroulement est le même que celui sous Dev C++, il vous faudra copier le contenu du dossier bin dans le dossier Windows/system32, le contenu du dossier include dans le dossier include de votre Visual Studio et pour finir le contenu du dossier lib dans le dossier lib de votre IDE.

II-C - Installation sous Code::Blocks

Code::Blocks est l'éditeur montant, vous le trouverez ici : http://www.codeblocks.org/

Le développement de Dev C++ fut arreté et l'équipe du projet se tourna vers Code::Blocks. Tout comme Dev C++, Code::Blocks dans sa version Windows peut être téléchargé avec le compilateur MinGW, de ce fait il vous faudra télécharger le même pack que celui de Dev C++.

Vous trouverez donc le .zip à cette adresse, section " Binary ", package pour MinGW : http://www.allegro.cc/files/

La démarche est identique, le contenu du dossier lib dans le dossier lib de Code::Blocks, les include dans le dossier include et les DLL toujours dans windows/system32.

III - Configuration & Premier programme

III-A - Configuration sous Dev-C++

Sous Dev C++, 2 choix sont possibles : le projet console et l'application Windows. Mais avant de taper une quelconque ligne de programmation il va falloir configurer le compilateur afin qu'il sache utiliser les bibliothèques de fonctions d'Allegro lors de la phase de "linkage".

Il existe 2 manières de compiler une application Allegro : effectuer un "linkage" statique ou dynamique.

III-A-1 - Linkage statique

Le "linkage" statique vous permettra de distribuer votre application sans avoir à la distribuer avec les DLL Windows d'Allegro. C'est un système qui peut s'avérer utile mais qui augmentera la taille de votre exécutable car il contiendra en plus de votre code, le code des fonctions d'Allegro (environs 500 ko).

Pour compiler votre application sous Dev C++ de manière statique il faut se rendre dans le menu Projet > Options du projet. Ensuite vous sélectionnez l'onglet Paramètres. C'est dans la section Editeur de lien que l'on va donner les renseignements au compilateur pour utiliser les library d'Allegro. Il faut copier la liste des library suivantes qui sont nécessaires à la compilation :

-lalleg_s -lgdi32 -lwinmm -lole32 -ldxguid -ldinput -lddraw -ldsound

- alleg_s : Bibliothèque statique des fonctions d'Allegro

- gdi32 : Bibliothèque classique Win32

- winmm : Bibliothèque Windows bas niveau pour le son

- ole32 : Bibliothèque Windows classique pour la gestion des objets OLE

- dinput : Bibliothèque Direct Input (composant de DirectX gérant les E/S)

- ddraw : Bibliothèque Direct Draw (composant de DirectX gérant l'affichage 2D)

- dsound : Bibliothèque Direct Sound (composant de DirectX gérant le son)

- dxguid : Bibliothèque de DirectX gérant le son également

Comme vous pouvez le voir, Allegro dans sa "version" Windows se base énormément sur DirectX ainsi que d'autres fonctions bas niveaux de l'API Windows. Afin de ne pas avoir à distribuer les DLL, il faut donc inclure aussi le code des fonctions sur lequelles Allegro se base.

Pour finir il faut indiquer dans la colonne compilateur l'option :
-DALLEGRO_STATICLINK.

III-A-2 - Linkage dynamique

La deuxième méthode consiste donc à se baser sur les DLL ce qui rendra la taille de l'exécutable plus petite mais obligera l'utilisateur à avoir les DLL d'Allegro pour pouvoir utiliser votre application.
La méthode est la même que pour le linkage statique sauf qu'au lieu de spécifier la longue liste des library d'Allegro il suffira juste de mettre dans la section Editeur de liens l'option : -lalleg.

Et voila, vous êtes enfin prêt à écrire votre premier programme à l'aide d'Allegro ! Mais avant, voyons comment se déroule la configuration sous Visual Studio.

III-B - Configuration sous Visual Studio

Sous Visual Studio il vous faudra créer un projet de type Win32 Application. Choisissez de créer un projet vide, cela vous évitera la génération automatique de certains fichiers sources par l'IDE.

Screenshot de Visual C++ 6.0

III-B-1 - Linkage statique

Tout comme sous Dev C++ vous avez la possibilité de compiler votre application de manière statique. Une fois votre projet crée il faudra vous rendre dans Projet > Settings (sous Visual Studio 6.0) et choisissez l'onglet Link. Le champ qui nous intéresse est : Object/Library modules. C'est ici qu'il va falloir indiquer le nom des library que nous allons utiliser.

Pour une compilation statique il faudra remplir le champ comme ceci :

alleg_s.lib gdi32.lib winmm.lib ole32.lib dxguid.lib dinput.lib ddraw.lib dsound.lib

III-B-2 - Linkage dynamique

La démarche est identique mais il faudra seulement préciser la library alleg.lib.

Attention !
Si vous utilisez Visual Studio Express 2005, il y a quelques différences : Il faut créer un nouveau projet vide dans la section Général et non pas une application Win32 comme l'on faisait.
De ce fait il va falloir configurer nous même les propriétés du projet. Voila la démarche à suivre pour pouvoir travailler dans les mêmes conditions :
Aller dans un Project / Properties. Section Configuration Properties / C/C++ / General modifier Debug Information Format en Program Database for Edit & Continue.
Dans Configuration Properties / C/C++ / Optimization modifier l'onglet Optimization en mettant disabled.
Dans Configuration Properties / C/C++ / Code Generation passer l'onglet Runtime Library à Multi-threaded Debug DLL.
Dans Configuration Properties / Linker / Input ajouter alld.lib dans Additional Dependencies.
Et pour finir dans Configuration Properties / Linker / Debugging passer Generate Debug à yes.
Source : http://awiki.tomasu.org/bin/view/Main/VisualCExpress2005

III-C - Configuration sous Code::Blocks

Pour créer une application Allegro sous Code::Blocks, il faut sélectionner une application de type Win32 GUI Applications.

III-C-1 - Linkage statique

Sous Code::Blocks, la configuration de la compilation se déroule dans Settings > Compiler, il faut ensuite choisir l'onglet Linker. Vous n'aurez pas à taper la liste des library à la main mais à travers le bouton Add (en bas à gauche), vous allez spécifier au compilateur ou se trouve les library qu'il devra utiliser lors de la phase de linkage.

Ces library sont les mêmes que ci dessus :

liballeg_s.a libgdi32.a libwinmm.a libole32.a libdxguid.a libdinput.a libddraw.a libdsound.a

Et vous les trouverez normallement dans le dossier lib de votre dossier d'installation de Code::Blocks.

N'oubliez pas d'indiquer dans Settings > Compiler , onglet Compiler > Other options, l'option : -DALLEGRO_STATICLINK

III-C-2 - Linkage dynamique

Il suffit simplement de préciser la library liballeg.a.

III-D - Premier programme

Le header file

Avant toute chose il faut include l'header file principal d'Allegro qui se nomme tout simplement : allegro.h, c'est lui que vous devrez include à chaque fois que vous aurez besoin d'une fonction d'Allegro.

C

#include <allegro.h>

(Note : il est possible de définir la constante ALLEGRO_STATICLINK avant l'inclusion de ce header. La définition de cette constante signalera au compilateur que nous souhaitons effectuer une compilation statique. Si on effectue cela, on n'aura pas à renseigner le champ Compilateur dans la configuration du projet. La syntaxe est : #define ALLEGRO_STATICLINK).

Le fonction main

Etant donné qu'Allegro est multi plateforme, il fallait trouver un moyen de rendre la fonction main compatible. Car chaque plateforme possède sa propre implémentation de main (winmain sous windows etc...) Pour cela il existe la macro END_OF_MAIN() qui se chargera de remplacer le main codé par un main en adéquation avec la plateforme ciblé. De ce fait, la fonction main d'un programme se basant sur Allegro aura toujours cette syntaxe :

C

int main(void)
{
/* code */
return 0 ;
} END_OF_MAIN() ;

Initialisation d'Allegro

Avant une quelconque utilisation, Allegro a besoins d'être initialisé. Pour cela il existe une macro qui initialise la library (récupération des informations du système, créations de variables globales etc...) Cette macro est : allegro_init().

Il s'agit en fait de l'appel simplifié :

C

install_allegro(SYSTEM_AUTODETECT, &errno, atexit);

Il faut obligatoirement appeler allegro_init() avant d'effectuer quoi que ce soit avec les fonctions d'Allegro. Il existe quelques exceptions que nous étudierons plus tard. Cette fonction renvoie 0 si tout s'est bien passé.

Notre premier programme ressemblera donc a cela :

C

#include <allegro.h>

int main(void)
{
/* Initialisation d'Allegro */
if(allegro_init() != 0)
return 1;

/* Affichage d'un message dans une boite de dialogue */
allegro_message("Hello World with Allegro !");

return 0 ;
} END_OF_MAIN() ;

Dans ce programme nous ne faisons qu'initialiser Allegro et afficher un message à l'écran. Nous étudierons en profondeur, dans le prochain article, l'affichage de texte sous Allegro.