Prince Mickaël

 

MOTEUR IRRLICHT

Mise en Œuvre sous Linux


 

SOMMAIRE

Installation d’Irrlicht sous Linux

Configuration d’un projet ou Linkage

Première scène

Device

Video Driver

Scene node

Identification des Nodes

Caméra

Keymap

Création d’une scène

Conclusion

Exercice

 

Installation d’Irrlicht sous Linux

 

  1. Télécharger Irrlicht

Il est contenu dans un Sofware Development Kit (SDK), on obtient les dossiers suivants :

  • 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.

 

  1. Dossier include 

Récupérer TOUS les fichiers .h contenu dans irrlicht/include

Les ajouter dans un nouveau dossier nommé : « irr », qu’on place dans le dossier (ordinateur) /usr/include

 

  1. Dossier lib et recompilation du moteur

Le dossier Irrlicht/lib/Linux est vide.

Il faut donc recompiler le moteur :

Dans le dossier irrlicht/source/irrlicht → ouvrez la console → écrivez  « make »:

Si tout se passe bien, le fichier libIrrlicht.a sera créé, il ne reste plus qu’à le placer dans le dossier lib :

/!\ Si on modifie le code source il faudra recompiler le moteur et les librairie statiques risque de ne plus être valable /!\

Configuration d’un projet ou Linkage

Le linkage consiste à lier la bibliothèque statique d’Irrlicht au compilateur. Il faut donc lier le ficher irrlicht.a

CODE::BLOCKS SANS IDE
Click-Droit sur le projet

Project->Build options->Linker Settings→add

choisir son fichier libirrlicht.a

Dans son éditeur

utilisez g++ pour compiler

« g++ source.cpp -lirrlicht -lGL -o executable »

note : Où source.cpp est bien sûr le nom du fichier source et executable le nom du binaire

 

Vous remarquez que Other linker options n’est pas vide, il s’agit d’autres librairie qui pourront nous être utile plus tard dans notre projet, elle sont optionelles ici mais il est important d’en connaître quelques unes.

  • -lGL : Il s’agit de la librairie openGL
  • -lXxf86vm :Il s’agit d’une librairie qui permet d’interagir avec le video mode
  • -lXext : Il s’agit d’une librairie qui permet de gérer les extensions du video mode du serveur x
  • -lX11 : il s’agit de la librairie directX11
  • -lXcusor : Il s’agit d’une librairie pour gérer les curseur de sourie

Première scène

Device

Dans un premier temps, nous allons linker la bibliothèque d’irrlicht avec notre projet. Pour cela nous allons utiliser la ligne ci-dessous :

Puis, nous allons créer un périphérique de sortie (ou fenêtre) que l’on nommera : « device » et qui sera un pointeur de type :  « irr::IrrlichtDevice »


Elle va récupéré les informations que la fonction : « irr:createDevice » va lui envoyer

  • deviceType : désigne l'API (un ensemble normalisé de classes, méthodes, fonctions, etc...) de graphique avec laquelle va s'interfacer Irrlicht. Dans la démonstration nous utiliserons OpenGL
  • windowSize : la taille de la fenêtre.
  • 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. En cas de 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 (zone tampon où l’image doit être dessiner) ou pas.
  • vsync : toujours un booléen. Celui-ci sert à activer la synchronisation verticale.
  • 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.

 

Il est intéressant de noter que dans le code ci-dessus, il est tout à fait possible d’éliminer beaucoup de texte – dans le but de rendre le code plus lisible – en utilisant des namespaces.

Le simple fait ajouter :

Vous permettra de réécrire le code comme ci dessus


vous remarquerez que tout de suite, le code devient bien plus lisible et par conséquence plus simple à écrire. Il est même possible de pousser ce systeme beaucoup plus loin en retirant « video » et « core » Mais à trop vouloir retirer nous pourrions avoir des difficulté à retrouver le type des éléments. Par conséquent, nous nous contenterons de retirer uniquement « irr »

Explication !

Nous allons instancier un device qui va recevoir les informations de CreateDevice. Il contiendra l’API OpenGL et fonctionnera sous 32bits dans une fenêtre de 800 par 600.
Le 32 représente le nombre de bits, le 1er false représente le plein écran, le true quant à lui le stencil buffer et pour ce qui est du 2e false, il s’agit de la synchronisation verticale. Enfin, le 0 de fin est ici pour indiquer que le device ne sera associer à rien.

 

Video Driver

Il faut instancier, à présent que notre device – fenêtre – est prêt, le video driver qui sera chargé de communiquer avec l’API bas niveau, dans notre exemple OpenGL. C’est ce que l’on nomme le Video driver. C’est également lui qui va générer le rendu.


Ensuite nous allons créer le graphe de scène (ou scene manager) qui va gérer tout le contenu de notre scène. Il faut comprendre par la que c’est lui qui va afficher les couleurs et les autres éléments présent dans le device.

Puis, pour terminer nous allons placer une caméra fixe :

Pour ce qui est des éléments présent ci-dessous, nous y reviendront plus tard.
Il ne nous manque plus qu’afficher le rendu, pour cela nous allons mettre en place une boucle qui appellera la scène, l’affichera et l’arrêtera. La boucle se répétera tant que le device existera :

Si nous analysons ce bout de code nous repérons bien la boucle qui se répete tant que device existe. Que la scène débute, qu’elle clear le back-buffer et le z-buffer. Et que la scène représentera une fenêtre blanche.

Enfin, le drawAll(), va calculer le rendu et endScene() va l’afficher.

Il reste une dernière étape avant d’avoir terminer ce chapitre: il faut encore libérer la mémoire et pour cela nous emploieront :

Scene node

Plus tôt l’ont a pu comprendre que le scene manager va gérer le contenue de la scène en stockant tous les éléments dans un node. Un Scene node est donc un élément du scene manager contenant un élément de la scène.

Ci-dessous quelques exemples :

  • IcameraSceneNode : Le node de la caméra
  • IlightSceneNode : Le node de la lumière
  • IsceneNode : l’ensemble des nodes, permettant au scene manager de les gérer plus facilement

Un node peut être comparé à une interface avec laquelle on va agir le plus clair de notre temps pour communiquer avec l’élément qu’il contient.

 

Identification des Nodes

Les nodes fonctionnent sous une forme arborescente et tous les nodes doivent avoir un node père, ils sont donc tous des node fils. Cependant, l’ont peux noter qu’ils se rejoignent tous sous le ISceneNode.

Pour ajouter un node au scene manager, il faut créer une méthode de ce dernier qui renverra un pointeur vers le node. Cette méthode ayant une convention de nommage, elle sera indiquer ci-dessous :

Caméra

La caméra est, comme son nom l’indique, l’outil visul par lequel notre œil va voir l’action. Il en existe 3 types au seil d’Irrlicht :

  • La caméra statique : qui ne bougera pas
  • La caméra Maya : orientation par clique gauche et mouvement par clique droit
  • La caméra FPS : caméra en vue subjectif

Les caméras, tout comme l’ensemble des éléments sont des nodes qui seront ensuite géré par le scene manager. Ci-dessous  le code que j’expliquerai brièvement :


Dans l’ordre de haut en bas :

  • Nous faisons appel au nœud parent (ici, IsceneNode) – qui gère les sceneNode comme expliquer précédemment -
  • Nous gérons la vitesse de rotation de la caméra
  • La vitesse de déplacement
  • Le numéro d’identification du nœud
  • Une map permettant de réaffecter les touches
  • la taille de la keymap
  • l’autorisation des déplacement sur l’axe verticale
  • la vitesse de déplacement lors des sauts
  • l’inversion de la rotation de la caméra
  • et pour finir, indique si la caméra est active ou non

Keymap

Au moment de la lecture des différents éléments présent dans le « addCameraSceneNodeFps » vous avez du remarquer l’apparition et la non explication de la taille de la keymap.

Venons en au fait.

La keymap est l’assignation des touches de votre clavier/sourie à différentes actions prévue par le moteur Irrlicht.


Il est également possible d’effectuer une réassignation des touches (en ZQSD par exemple)

Création d’une scène

Nous disposons de tout le nécessaire pour créer une scène à présent :

  • Le Device
  • Le Video driver
  • Les scenes node
  • la caméra
  • la keymap

Notre objectif pour notre première scène sera de créer un cube.

Conclusion

Après avoir téléchargé le moteur Irrlicht et en avoir exploré le contenu, nous ferons face à différents fichiers qui nous confronteront au moteur 3D qui fonctionne avec le langage de programmation C++.

De plus, ce moteur nous demande également quelques bases d’algorithmie ainsi que de programmation orientée objets.

Il sera alors possible de créer dans un Device – ou fenêtre – une scène qui affichera plusieurs Node – éléments – qui se joueront tant que la scène sera active.

Exercice

La mise en oeuvre du moteur irrlicht sous Linux (présentation, installation, exemples de code)

 

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *