Aller au menu - Aller au contenu

Icône Mise en place

Avatar
Par Avatar Kevin Leonhart
Mise à jour : 23/03/2011
Difficulté : Facile Facile Creative Commons BY-SA
1 621 visites depuis 7 jours, dont 147 sur ce chapitre classé 80/786
Ce chapitre a pour objectif d'installer Irrlicht et de vérifier qu'il fonctionne. Théoriquement ce n'est pas bien compliqué. Toutefois si vous rencontrez un problème que vous n'arrivez pas à résoudre après avoir bien relu les différentes étapes, vous pouvez le poster sur les forums pour avoir de l'aide.

N'y connaissant rien à Mac OS, je ne donnerais pas de procédure détaillé pour ce système. Néanmoins les grandes lignes de l'installation restent les mêmes, vous ne devriez donc pas avoir trop de problèmes.
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Installation

Comme la plupart des grosses bibliothèques logicielle, Irrlicht est contenu dans un SDK, un Software Development Kit. Il s'agit en clair d'un dossier qui va contenir tout ce dont on a besoin pour développer des applications avec cette bibliothèque. Première étape donc, télécharger la dernière version du SDK à cette adresse : http://irrlicht.sourceforge.net/downloads.html.


Une fois que vous l'avez récupéré et décompressé, jetons un œil à ce qu'il contient :
  • bin : les bibliothèques dynamiques et les binaires des exemples du SDK.
  • changes.txt : est ce qu'on appelle le changelog, une archive contenant tous les changements du moteur depuis sa première release (sortie).
  • doc : une copie intégrale de la documentation du moteur.
  • examples : les codes sources de petites applications illustrant les fonctionnalités du moteur et les tutoriels associés.
  • include : les principaux headers du code source.
  • lib : les bibliothèques statiques.
  • media : des images, textures modèles 3D, etc...
  • readme.txt : quelques informations sur le SDK
  • source : le code source du moteur
  • tools : quelques utilitaires comme un visualiseur de modèle 3D, un éditeur de scène, etc...


Pour l'installation proprement dite, seuls 3 dossiers nous intéressent :
  • bin
  • include
  • lib



Dossier bin


Comme nous l'avons vu plus haut, celui-ci contient les bibliothèques dynamiques. Les fameuses dll sous Windows. Pour les utilisateurs de cet OS justement, il vous suffit de choisir le dossier correspondant à votre configuration et de copier le fichier .dll quelque part. Vous devrez le mettre dans le même dossier que vos fichiers exécutables (.exe) pour que ceux-ci fonctionnent.

Pour les utilisateurs de GNU/Linux c'est encore plus simple, il n'y a pas de bibliothèque dynamique. Ce qui signifie que tout sera compilé en statique dans le programme final. Rien à récupérer dans ce dossier donc.



Dossier include


Comme vous pouvez le constater, le dossier include ne contient pas de sous-dossiers. Les headers sont les mêmes pour tout le monde. Remarquez au passage le fichier irrlicht.h, c'est lui que nous allons inclure dans tous nos programmes. Si vous l'ouvrez vous pourrez voir qu'au début il inclut tous les autres headers du dossier. Ce qui signifie qu'il suffit de rajouter une ligne pour pouvoir utiliser tout le moteur :

Code : C++
1
#include <irr/irrlicht.h>


Suivez bien ce qui est noté ci-dessous pour comprendre cette ligne. Elle n'est pas "universelle".

Il vous faut maintenant copier l'intégralité du dossier dans le dossier include de votre compilateur. Sous GNU/Linux il s'agit généralement du dossier /usr/include. Pour éviter d'en "mettre partout", il est préférable de créer un dossier spécifique nommé irr par exemple (d'où le irr/irrlicht.h de l'inclusion).



Dossier lib


Dernière étape avec le dossier lib qui contient les bibliothèques statiques. Les utilisateurs de Windows connaissent le chemin, il suffit de choisir le dossier correspondant à sa configuration puis d'en copier le contenu dans le dossier lib de son compilateur.

Les utilisateurs de GNU/Linux en revanche vont devoir faire quelques efforts. En effet si vous regardez dans le sous-dossier Linux, vous verrez que celui-ci est vide. Et qui dit pas de bibliothèque statique dit pas de chocolat compilation possible. Il va donc vous falloir recompiler le moteur pour obtenir le précieux fichier.

Pas de panique, vous trouverez en annexe un petit chapitre expliquant la marche à suivre. Il peut être utile par ailleurs de recompiler le moteur s'il vous prends un jour l'envie de modifier quelque chose dans le code source par exemple. Auquel cas la bibliothèque statique ne sera plus valable.

Une fois que vous avez votre fichier (qui devrait s'appeler libIrrlicht.a), il suffit de le copier dans le dossier /usr/lib/. Et voilà ! Irrlicht est maintenant installé. Ce n'était pas si dur, si ? ;)
Retour en haut

Configurer un projet

Avec IDE



Commencez donc par ouvrir votre IDE favori et créez-y un nouveau projet. Même si l'IDE possède des modèles spécifiques à Irrlicht, il serait préférable de partir sur un projet vierge de base. Ensuite, quel que soit le code présent dans le fichier main.cpp, il est bon de le remplacer par le code suivant pour tester que l'environnement fonctionne sans Irrlicht :

Code : C++
1
2
3
4
5
6
#include <iostream>
 
int main(void) {
  std::cout << "Hello world!" << std::endl;
  return 0;
}

Rien de nouveau j'espère, ce code affiche simplement "Hello world!" dans la console. Au cas où un problème survient à ce niveau, l'installation de votre IDE est en cause. Partons du principe que tout fonctionne et ajoutons la ligne qui va inclure tous les headers nécessaires à l'utilisation d'Irrlicht :

Code : C++
1
#include <irr/irrlicht.h>


Vient enfin l'étape la plus complexe : le "linkage". L'opération consiste à "linker" (lier) la bibliothèque statique d'Irrlicht au compilateur. Il faut donc indiquer au linker le fichier .a ou .lib que nous avons mis tout à l'heure dans le sous-dossier lib du compilateur via l'IDE.

Sous code::blocks par exemple, la manipulation à effectuer est Project->Build options->Linker Settings->add. Il faut ensuite choisir le fichier .a ou .lib. Il est toutefois possible que ce fichier seul ne suffise pas. Bien souvent il faut également indiquer les bibliothèques statiques d'OpenGL, GLU ou encore Xfree86. Si le compilateur vous renvoie un message d'erreur concernant ce problème, le nom de la bibliothèque manquante est souvent indiqué plus ou moins clairement.




Sans IDE



Sans IDE c'est encore plus simple. Utilisez votre éditeur favori pour les codes sources, puis utilisez g++ pour compiler. Si vous avez correctement suivi la partie sur l'installation et que votre configuration est bien faite par ailleurs, la commande suivante devrait faire l'affaire :

Code : C++
1
g++ source.cpp -lIrrlicht -lGL -o executable

Où source.cpp est bien sûr le nom du fichier source et executable le nom du binaire. Selon votre plateforme il faudra peut être linker plus de bibliothèque que ces 2 là. L'idéal est de se concocter un petit makefile [10-2] pour pouvoir gérer facilement les options de compilation et les projets à multiples fichiers sources. Faîtes vous plaisir. ;)
Retour en haut

Premier projet

Bien, c'est maintenant qu'on rentre dans le vif du sujet. Sans plus attendre la première ligne de code :

Code : C++
1
2
3
4
5
6
7
8
irr::IrrlichtDevice *device = irr::createDevice (
    irr::video::EDT_OPENGL,
    irr::core::dimension2d<irr::u32>(800,600),
    32,
    false,
    true,
    false,
    0);


Ouch ! Oui je sais ça fait peur, mais pas de panique on va tout reprendre point par point. La première des choses est encore de savoir à quoi sert cette ligne. En fait elle va créer un périphérique de sortie, aussi appelé contexte d'affichage, ou plus communément... fenêtre. Qui sera un pointeur de type irr::IrrlichtDevice, et que nous appellerons simplement device. Cette ligne permet donc de créer la fenêtre dans laquelle votre application va se dérouler (et bien plus encore mais on verra ça plus tard ;) ).


Cela a dû vous sauter aux yeux, le namespace irr:: revient sans arrêt. La raison en est simple : dans Irrlicht tout est contenu dans le namespace irr. Personnellement je préfère le retaper à chaque fois mais si cela vous est vraiment insupportable vous pouvez toujours ajouter la ligne suivante au début de votre code :

Code : C++
1
using namespace irr;


Ce qui est impressionnant dans cette fonction c'est le nombre de paramètres qu'elle prend, 7 en tout. Examinons sa déclaration plus en détail :

Code : C++
1
irr::createDevice (deviceType, windowSize, bits, fullscreen, stencilbuffer, vsync, receiver)

  • deviceType : désigne l'API graphique avec laquelle va s'interfacer Irrlicht. Nous utiliserons OpenGL tout au long du tutoriel, mais on peut aussi choisir Direct3D par exemple en mettant la valeur EDT_DIRECT3D9.
  • windowSize : la taille de la fenêtre. Tout est dit ! Avec le code indiqué plus haut, on crée une fenêtre de 800 par 600 pixels.
  • bits : détermine le nombre de bits par pixels. En mettant 32, on aura 232 valeurs différentes possibles par pixel.
  • fullscreen : un booléen qui indique si on veut faire du plein écran ou pas. Pour la valeur true l'application sera en plein écran, et pour false la fenêtre sera de la taille définie plus haut.
  • stencilbuffer : un autre booléen qui indique lui si on active le stencil buffer [32-2] ou pas. Il est actif pour true.
  • vsync : toujours un booléen. Celui-ci sert à activer la synchronisation verticale [31-3]. Pas de mystère, elle est active pour true.
  • receiver : permet d'associer un capteur d'événements au device (0 signifie qu'on n'associe rien). Nous verrons de quoi il s'agit dans un prochain chapitre.

Reprenons notre première ligne, on s'aperçoit qu'on a créé une fenêtre utilisant OpenGL de 800 x 600 pixels avec 32 bits par pixel ayant un stencil buffer. Il est intéressant de noter que tous les paramètres de cette fonction possèdent des valeurs par défaut (comme indiqué dans la documentation [21-2]).




Les éléments de base


Maintenant que nous avons le device (qui est le véritable nom de la "fenêtre"), nous allons instancier la classe qui communique avec les API 3D bas niveau (OpenGL dans notre cas), j'ai nommé le video driver. C'est lui qui va gérer le rendu par exemple :

Code : C++
1
irr::video::IVideoDriver* driver = device->getVideoDriver();


Continuons en créant le graphe de scène, aussi appelé scene manager, que nous aborderons plus en détails dans le prochain chapitre. C'est lui qui va nous permettre de gérer tout ce qui est contenu dans la scène :

Code : C++
1
irr::scene::ISceneManager *sceneManager = device->getSceneManager ();


Pour finir mettons une caméra fixe. Je passe sur les paramètres mais nous reviendrons dessus dans le chapitre suivant le prochain :

Code : C++
1
2
3
sceneManager->addCameraSceneNode (0,
    irr::core::vector3df (0,0,0),
    irr::core::vector3df (5,0,0));




Le rendu


Il ne reste plus maintenant qu'à afficher le rendu. Pour ce faire nous utilisons une boucle qui sera parcourue de manière infinie tant qu'on décide de ne pas fermer l'application :

Code : C++
1
2
3
4
5
6
while(device->run()) {
    driver->beginScene (true, true,
        irr::video::SColor(255,255,255,255));
    sceneManager->drawAll ();
    driver->endScene ();
}


Quelques explications s'imposent. La condition utilisée pour la boucle est le résultat de la méthode run du device. Celle-ci renvoie false quand Irrlicht détecte un signal d’arrêt et true dans tous les autres cas. Ce qui veut dire que cette boucle tournera indéfiniment jusqu'à ce qu'on mette fin au programme.

Les signaux d'arrêt varient d'une plateforme à l'autre. Sous Windows, la combinaison de touche alt + F4 fonctionne généralement toujours. Sous Linux c'est beaucoup moins évident. Avec le WM Awesome par exemple, c'est la combinaison de touche mod + shift + c qui permet de fermer l'application proprement.

Il est aussi intéressant de noter que cette boucle ne gère absolument pas le temps. Ce qui signifie qu'une fois lancée, l'application utilisera toute la puissance disponible de votre processeur. En soi ça n'a rien de gênant mais ça peut surprendre.



Décortiquons maintenant cette ligne :

Code : C++
1
driver->beginScene (true, true, irr::video::SColor(255,255,255,255));


Cette fonction permet d'effectuer un rendu. Elle ne le fait pas elle-même mais est indispensable. En gros elle prépare le terrain pour le nouveau rendu. Voyons un peu son prototype :

Code : C++
1
IVideoDriver::beginScene (backBuffer, zBuffer, color, videoData, sourceRect)

  • backBuffer : il s'agit d'un booléen qui permet d'indiquer si on veut effacer le back buffer [32-3] ou pas. Pour faire court disons que si on ne l'efface pas des réminiscences se créeront là où il n'y a rien à afficher.
  • zBuffer : encore un booléen. Celui-ci indique si on désire effacer le contenu du Z-Buffer [32-1].
  • color : ce paramètre indique la couleur que va avoir le fond de l'écran. C'est une notation RGB classique, mais méfiance toutefois, ici le premier nombre indique la composante alpha. Cet exemple donne donc un fond blanc et opaque. Nous aurons l'occasion de revenir sur les couleurs par la suite.
  • videoData : permet de faire du multi-fenêtrage. Nous n'y toucherons pas, donc on laisse la valeur par défaut.
  • sourceRect : permet de n'afficher qu'une partie du rendu. Là encore nous n'y toucherons pas.


Maintenant les deux dernières lignes :

Code : C++
1
2
sceneManager->drawAll ();
driver->endScene ();

La méthode drawAll du sceneManager va s'occuper du rendu de tout ce qui est géré par le scene manager. Donc de tout ce qui se trouve dans la scène. Et enfin la méthode endScene du driver va afficher ledit rendu à l'écran. Sans elle rien ne s'afficherait.



Pour terminer l'application proprement il nous reste à mettre une dernière ligne, hors de la boucle. Elle permet de détruire le device et donc de libérer la mémoire :

Code : C++
1
device->drop ();



Voici un récapitulatif du code que vous devriez avoir:

Code : C++
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <irr/irrlicht.h>
 
int main(void) {

    irr::IrrlichtDevice *device = irr::createDevice( // creation device
        irr::video::EDT_OPENGL,                      // l'API est OpenGL
        irr::core::dimension2d<irr::u32>(800,600),   // taille de la fenetre 800x600
        32, false, true, false, 0);
 
    irr::video::IVideoDriver* driver =
        device->getVideoDriver();                    // creation driver
    irr::scene::ISceneManager *sceneManager =
        device->getSceneManager ();                  // creation scene manager
 
    sceneManager->addCameraSceneNode (0,             // ajout camera fixe
        irr::core::vector3df (0,0,0),
        irr::core::vector3df (5,0,0));

    while (device->run()) {                          // la boucle de rendu
        driver->beginScene(                          // demarre le rendu
            true,                                    // clear back-buffer
            true,                                    // clear z-buffer
            irr::video::SColor(255,255,255,255));    // fond blanc
        sceneManager->drawAll ();                    // calcule le rendu
        driver->endScene ();                         // affiche le rendu
    }

    device->drop ();                                 // liberation de la memoire
    return 0;
}


Un coup de compilateur et que voyez-vous apparaître sous vos yeux ébahis ? Une fenêtre de 800 par 600 toute blanche. Rassurez-vous c'est normal.. Ce code peut être considéré comme le code minimal d'une application Irrlicht, il ne fait rien de particulier et sert de base pour le reste.

Dans le chapitre suivant le prochain nous ajouterons quelques lignes pour ajouter un cube et commencer à faire des choses un peu plus palpitantes. ^^
Retour en haut
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut

Lire aussi

Icône
Installation et configuration
Icône
Le SDK
Icône
Installation et configuration
Icône
Structures de données
Retour en haut
35 commentaires pour "Mise en place"
Note moyenne : 3.60 / 4 (122 votes)
Pseudo Commentaire
Hors ligne Genroa # Posté le 02/05/2011 à 18:16:50

Avis : Bon

Sous code blocks, jai bien tout fait comme il faut, mais a la compilation il m'écrit "irrlicht - Debug uses an invalid compiler".
Help... ^^'
Hors ligne Beydamo # Posté le 22/05/2011 à 09:09:27
Avatar

Avis : Décevant

Ou est le dossier usr ??
Hors ligne Petit Phil's # Posté le 19/07/2011 à 10:58:25
Avatar

Avis : Très bon

Ville : Montromant
Pays : France métropolitaine

 Beydamo -> peut être que ça peut t'aider:
Citation : Superjaco
Si vous êtes sous Windows, le dossier à choisir correspond à votre compilateur.
- Pour gcc : c'est Win32-gcc
- Pour Visual C++ : c'est Win32-VisualStudio


Moi j'utilise Code::Block sous Windows et mon dossier est MinGW.

Bon tutoriel sinon Kevin Leonhart, merci d'avoir prit du temps pour nous! ;)

Juste une petite remarque:

Citation : Kevin Leonhart
Dossier lib

Dernière étape avec le dossier lib qui contient les bibliothèques statiques. Les utilisateurs de Windows connaissent le chemin, il suffit de choisir le dossier correspondant à sa configuration puis d'en copier le contenu dans le dossier lib de son compilateur.

Les utilisateurs de GNU/Linux en revanche vont devoir faire quelques efforts. En effet si vous regardez dans le sous-dossier Linux, vous verrez que celui-ci est vide. Et qui dit pas de bibliothèque statique dit pas de chocolat compilation possible. Il va donc vous falloir recompiler le moteur pour obtenir le précieux fichier.

Pas de panique, vous trouverez en annexe un petit chapitre expliquant la marche à suivre. Il peut être utile par ailleurs de recompiler le moteur s'il vous prends un jour l'envie de modifier quelque chose dans le code source par exemple. Auquel cas la bibliothèque statique ne sera plus valable.


Lorsque je clique sur le lien le site m'affiche un message me disant: "Vous n'avez pas le droit de lire ce tutoriel.". :-°

Merci encore de prendre le temps partager tes connaissances ! :)
L'or s'éprouve avec le feu ! ;)

OS: Ubuntu 11.10 / Windows7 - - Processeur Intel® Core™ i3 CPU M 380 @ 2.53GHz × 4 - - Carte graphique RADEON HD6370M 1GB
 
Hors ligne did0u # Posté le 22/08/2011 à 19:03:51

Études : IUT Nantes

 Bonjour, j'ai un problème. Pourrez vous m'aidez. J'ai beau faire exactement faire tout ce que dit Kevin Leonhart en mettant les include, les .dll et les lib(.a) au bon endroit, à la compilation l'IDE me dit irr/irrlicht No such File. Je n'en peux plus j'ai tout essayer !!!
Pouvez vous m'aidez merci.
Hors ligne narsdil # Posté le 10/05/2012 à 21:27:41
Avatar

Avis : Mitigé

Tuto pas trop bien expliqué pour les débutants(dont moi) je trouve!
J'ai finalement réussi à installer tant bien que mal et j'ai écrit tout le code à la main et quand je lance mon projet, un message d'erreur apparait en me disant que "ce programme a cessé de fonctionner" (je suis sous windows 7) et même quand je copie colle le résumé de code, ça me fait le même problème...
à coups de cout je suis arrivé à voir que le programme plante au : "sceneManager->addCameraSceneNode (0,core::vector3df (0,0,0),core::vector3df (5,0,0));"
(j'ai fait using namespace std; ;)

EDIT : j'ai réussi à faire marcher mon programme rien qu'en lancant l'executable qui est dans mon dossier de sortie avec le .dll.
En fait, il faut pas lancer avec code::blocks, juste "manuellement" avec le .exe :lol: .
La limite est une invention de l'homme...
 

Voir tous les commentaires