Tutoriel Irrlicht 1

Nous utiliserons l'EDI Microsoft Visual Studio sous Windows mais les manipulations restent similaires si vous utilisez un EDI ou un système d'exploitation différent.

Pour utiliser le moteur, vous devez inclure le fichier d'en-tête <irrlicht.h>.

Ce fichier d'en-tête peut être trouvé dans le dossier « include » du SDK d'Irrlicht Engine.

Pour que le compilateur puisse trouver ce fichier, il est nécessaire d'indiquer le répertoire où il se trouve.

Cette opération est différente pour chaque EDI et compilateur que vous utilisez. Voyons rapidement comment le faire sous Microsoft Visual Studio.

Si vous utilisez la version 6.0, allez dans le Menu « Extras » ? « Options » .

Sélectionnez l'onglet dossier et sélectionnez l'entrée « Include » dans la liste déroulante.

Ajoutez le dossier « include » contenu dans le dossier du moteur Irrlicht à la liste des dossiers.

Maintenant le compilateur pourra trouver l'en-tête Irrlicht.h.

Nous avons aussi besoin du fichier Irrlicht.lib , restez dans cette fenêtre, sélectionnez « Bibliothèques » dans la liste déroulante et ajoutez le dossier « lib/VisualStudio ».

Si votre EDI est Visual Studio.NET, allez dans « Outils » ? « Options ».

Cliquez sur « Projets et solutions » puis sélectionnez « répertoires de VC++ ».

Sélectionnez « Afficher les répertoires pour : Fichiers Include» dans la liste déroulante et ajoutez le dossier « include » contenu dans le dossier du moteur Irrlicht à la liste des dossiers.

Maintenant le compilateur pourra trouver l'en-tête Irrlicht.h.

Nous avons aussi besoin du fichier Irrlicht.lib, restez dans cette fenêtre, sélectionnez « Afficher les répertoires pour : Fichiers bibliothèques » et ajoutez le dossier « lib/VisualStudio ».

C'est tout. Maintenant que votre EDI est configuré, vous êtes désormais capable de développer des applications avec le moteur Irrlicht.

Commençons !

Une fois l'EDI configuré, le compilateur pourra trouver le fichier d'en-tête du moteur Irrlicht nous pouvons donc l'inclure dans notre code.

#include <irrlicht.h>

Dans le moteur Irrlicht, tout est dans le namespace « irr ». Donc si vous désirez utiliser une classe du moteur, vous devez écrire « irr:: » avant le nom de la classe.

Par exemple, pour utiliser « IrrlichtDevice » écrivez : « irr::IrrlichtDevice ».

Pour ne pas avoir à mettre « irr:: » devant chaque nom de classe, nous pouvons dire au compilateur que nous utilisons ce namespace nous n'aurons alors plus à écrire « irr:: ».

using namespace irr;

Il y a cinq sous-namespaces dans le moteur Irrlicht. Regardez-les, vous pouvez lire leur description détaillée dans la documentation. Pour garder cet exemple simple, nous ne réécrirons pas ces cinq sous-namespaces.

Comme avec le namespace irr nous allons donc dire au compilateur que nous ne voulons pas écrire leurs noms à chaque fois..

using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

Pour pouvoir utiliser Irrlicht.DLL, nous avons besoin de lier Irrlicht.lib au projet.

Nous pourrions mettre cette option dans les paramètres de projet mais pour le faire plus facilement, nous utilisons un « pragma comment lib » pour Visual Studio(4).

Sur les plates-formes Windows, nous devons nous débarrasser de la console qui apparaît quand nous lançons le programme par main(). Ce qui est fait avec le second pragma. Nous pourrions aussi utiliser la fonction WinMain() mais nous perdrions alors l'aspect multiplate-forme du code.

#ifdef _IRR_WINDOWS_
#pragma comment(lib, "Irrlicht.lib")
#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
#endif

Ceci est la fonction main(). Nous pouvons maintenant utiliser main() sur chaque plate-forme.

int main()
{

La plus importante fonction du moteur est la fonction createDevice(). Elle crée un IrrlichtDevice qui est l'objet racine pour faire n'importe quoi avec le moteur. CreateDevice() accepte sept paramètres :

• deviceType : type du périphérique. Il peut être le Null-device(5), un des deux logiciels de rendu (D3D8, D3D9) ou OpenGL. Dans ces exemples nous utiliserons EDT_SOFTWARE mais vous pourriez aussi essayer avec EDT_BURNINGSVIDEO, EDT_NULL, EDT_DIRECT3D8, EDT_DIRECT3D9 ou EDT_OPENGL ;
• windowSize : la taille de la fenêtre ou la résolution de l'écran en FullScreenMode(6). Dans cet exemple, nous utiliserons 640x480 ;
• bits : nombre de bits de couleurs par pixel. Il devrait être 16 ou 32. Le paramètre est souvent ignoré lors d'une exécution en mode fenêtré ;
• fullscreen : détermine si nous voulons que le système s'exécute en mode plein écran ou non ;
• stencilbuffer : détermine si nous voulons utiliser le « stencil buffer » (pour dessiner des ombres) ;
• vsync : détermine si nous voulons avoir la vsync activée, ceci est utile uniquement en mode plein écran ;
• eventReceiver : un objet qui reçoit les événements. Nous ne voulons pas utiliser ce paramètre ici, nous le mettons donc à 0.

Toujours vérifier la valeur retournée pour gérer les pilotes, les dimensions, etc. non supportés.

    IrrlichtDevice *device =
        createDevice( video::EDT_SOFTWARE, dimension2d<u32>(640, 480), 16,
            false, false, false, 0);

    if (!device)
        return 1;

Rajoutons un joli titre à la fenêtre. Remarquez qu'il y a un 'L' devant la chaîne de caractères. Le moteur Irrlicht utilise des chaînes de caractères étendus pour afficher du texte.

device->setWindowCaption(L"Hello World! - Irrlicht Engine Demo");

Récupérez un pointeur sur le VideoDriver, le SceneManager et l'environnement de l'interface graphique utilisateur pour ne pas avoir à réécrire device->getVideoDriver(), device->getSceneManager(), ou device->getGUIEnvironment().

    IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();
    IGUIEnvironment* guienv = device->getGUIEnvironment();

Nous ajoutons un texte « hello world » sur la fenêtre en utilisant l'environnement GUI.

Le texte est placé à la position (10,10) comme coin supérieur gauche et (260,22) comme coin bas droit.

guienv->addStaticText(L"Hello World! This is the Irrlicht Software renderer!",
        rect<s32>(10,10,260,22), true);

Pour montrer quelque chose d'intéressant, nous chargeons et affichons un modèle de Quake 2.

Nous devons seulement obtenir le Mesh(7) à partir du SceneManager avec getMesh() et ajouter un SceneNode pour afficher le mesh avec addAnimatedMeshSceneNode(). Nous vérifions la valeur de retour de getMesh() pour être notifié des problèmes de chargement et d'autres erreurs.

Au lieu d'écrire le nom de fichier « sydney.md2 » il est aussi possible de charger un fichier objet Maya (.obj), une carte complète de Quake 3 ( .bsp) ou tout autre fichier supporté.

À propos, ce modèle sympa de Quake 2 nommé Sydney a été modélisé par Brian Collins.

 IAnimatedMesh* mesh = smgr->getMesh("../../media/sydney.md2");
    if (!mesh)
    {
        device->drop();
        return 1;
    }
    IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );

Pour rendre le mesh un peu plus joli, nous changeons son matériel. Nous désactivons l'éclairage parce que nous n'avons pas de lumière dynamique ici et le mesh serait totalement noir sinon. Puis nous mettons en place la boucle d'animation, de sorte que l'animation STAND prédéfinie soit utilisée. Finalement, nous appliquons une texture au mesh. Sans cela le mesh serait dessiné avec une seule couleur.

if (node)
    {
        node->setMaterialFlag(EMF_LIGHTING, false);
        node->setMD2Animation(scene::EMAT_STAND);
        node->setMaterialTexture( 0, driver->getTexture("../../media/sydney.bmp") );
    }

Pour voir le mesh, nous plaçons une caméra dans un espace 3D à la position (0,30,-40). La caméra regarde vers (0,5,0) ce qui est approximativement l'endroit où se trouve notre modèle md2.

smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));

Bon maintenant nous avons défini la scène, dessinons-la :

Nous lançons le pilote dans une boucle while() tant que le pilote ne veut pas s'arrêter. Ceci arrivera lorsque l'utilisateur fermera la fenêtre ou pressera ALT+F4 (ou toute autre combinaison de touches fermant une fenêtre).

 while(device->run())
    {

Tout peut être dessiné entre les appels de beginScene() et de endScene(). L'appel de beginScene() efface l'écran avec une couleur ainsi que le tampon de profondeur si désiré.

Ensuite, nous laissons le SceneManager et l'environnement GUI dessiner leur contenu.

Lors de l'appel à la fonction endScene() tout est affiché à l'écran.

 driver->beginScene(true, true, SColor(255,100,101,140));

        smgr->drawAll();
        guienv->drawAll();

        driver->endScene();
    }

Après avoir fini avec la boucle de rendu, nous devons supprimer le système Irrlicht créé précédemment avec createDevice(). Dans le moteur Irrlicht, vous devez supprimer tous les objets que vous avez créés avec une méthode ou une fonction commençant par « create ». L'objet est simplement supprimé en appelant ->drop(). Regardez la documentation à irr::IReferenceCounted::drop() pour plus d'informations.

    device->drop()
    return 0;
}

C'est tout, compilez et exécutez.

Vous pouvez désormais faire un code minimal utilisant Irrlicht.

Dans le prochain tutoriel Quake3Map, nous verrons comment créer, charger une scène Quake 3, créer une SceneNode et créer un contrôle utilisateur sur la caméra.

Merci à Nikolaus Gebhardt de nous permettre de traduire ce tutoriel.

Merci à LittleWhite et à Winjerome pour leur relecture technique ainsi qu'à ClaudeLELOUP pour sa relecture orthographique.