Download Download Documentation Forum View Odfaeg on GitHub CV Travail de fin d'études

Les entités de haut niveau.

Les entités de bas niveau (celles héritant de la classe odfaeg::graphic::drawable) peuvent ne pas suffire pour des jeux
plus complexe, c'est pourquoi ODFAEG possède ses propres type d'entités.
Toutes ces entités héritent de la classe odfaeg::graphic::Entity.
Les entités possèdent également plusieurs propriétés intéressantes :

  • Une liste de faces.
  • Une matrice de transformation.
  • Un type.
  • Une liste d'entités enfant.
  • Une entité parent.
  • Un id.
  • Des états. (Pouvant être de n'importe quel type)
  • Une hiérarchie de volumes de collision.

Les entités tout comme les widgets de QT peuvent donc avoir plusieurs entités enfants et une entité parent afin
de constituer une hiérarchie, ceci implique que tout changement de proriété affectant une entité parente,
affectera aussi les propriétés des entités enfants de celle-ci.
Par exemple si vous avez une entité parente A qui contient deux entités enfantes B et C, par défaut, lorsque l'on déplacera
l'entité A, les entités B et C le seront également. (Même chose en ce qui concerne les autres type de transformations)


Les faces :

Les faces continnent elles aussi plusieurs propriétés intéressantes tel que :

  • Un tableau de sommet.
  • Une matrice de transformation.
  • Un matériel.


Les matériaux :

Les matériaux peuvent contenir également quelques propriétés intéressantes tels que :

  • Une ou plusieurs textures.
  • L'intensité de la composante spéculaire.
  • La puissance de la composante spéculaire.
  • Les indices de réfractions et de disfraction du matériel.
  • Une "bumpmap". (Une texture de relief de la texture de la face utilisée pour calculer l'éclairage sur la texture)

Quelque exemples d'entités :

Les tiles (odfaeg::graphic::Tile) : celles-ci contiennent une seule face composée de quatre sommets.
Les décors (odfaeg::graphic::g2d::Decor) : Décors en 2D, même chose que les tiles à part que ceux-ci possèdes un matrices générant des ombres.
Les animations : celles-ci possèdent un groupe d'entités (des frames) qui seront affichées les unes après les autres.
Les grandes tiles (odfaeg::graphic::BigTile) : celles-ci sont composée de plusieurs tiles afin de former par exemple un terrain.
Les murs (odfaeg::graphic::g2d::Wall) : ceux-ci contiennent une matrice de projection des ombres, et un id pour chaque type de murs qui
est utilisé pour la génération de bord de carte et de labyrinthes.
Les lumières ponctuelles : ce sont juste des lumières en forme de cercles ou d'éllipse.

Les entités par défaut de ODFAEG.

Chaque entité ODFAEG doit être créée à partir d'une factory : un objet de la classe EntityFactory, vous devez donc en déclaré un dans la classe qui.
Hérite de la classe Application.


          odfaeg::graphic::EntityFactory entityFactory;

Les tiles :
Le constructeur de la classe odfaeg::graphic::Tile attend plusieurs paramètres :
  • Le premier est un pointeur vers une texture, qui sera placée sur le quadrilatère formé par les 4 sommets de la tile.
  • Le second est la position de la tile. (tuile)
  • Le troisième est la taille de la tile.
  • Le quatrième est la partie de la texture qui sera placée sur le quadrilatère.
  • Le cinquième est la factory.
Les deux derniers paramètres sont la couleur de la tile (blanc par défaut) et un pointeur vers une entité parente (null par défaut).


Les grandes tiles et le sol.
Celles-ci sont simplement des groupes de tiles dont les bords se touchent.
Le constructeur de cette classe n'attend que 2 paramètres :

  • Le premier est la position.
  • Le second est l'entity factory.
  • Les deux derniers sont utilisé par le générateur de terrain : la taille d'une tile et le nombre de tiles par ligne.
La méthode addTile permet d'ajouter une tile au terrain, elle attend en paramètre un pointeur sur la tile à ajouter,
les deux paramètres suivants sont utilisé par la générateur de terrain : la position de la tile et un tableau pour la hauteur des 4 coins de la tile.
La méthode getHeight en 3D permet de récupérer la hauteur du terrain en un point bien précis, elle attend en paramètre un point et une référence pour récupérer la hauteur du terrrain.
La méthode renvoie un booléen qui renvoie vrai si le point est sur le terrain.
Si le terrain est en 2D, la hauteur renvoyée est la position en y du point.

Les décors :

Le constructeur de la classe odfaeg::graphic::g2d::Decor attend plusieurs paramètres également :

  • Le premier est un pointeur sur la tile utilisée pour afficher le décor
  • Le second, est un pointeur vers une lumière (par exemple le soleil) pour calculer la matrice de transformation des ombres.
  • Le troisième, est l'entity factory.

Les murs :
Le constructeur de la classe odfaeg::graphic::g2d::Wall prend plusieurs paramètres dont :
  • Un pointeur vers la tile du mur.
  • Le type du mur. (Par exemple TOP_LEFT pour le mur en haut à gauche.)
  • Le troisième est un pointeur vers une lumière (par exemple le soleil) pour calculer la matrice de transformation des ombres.
  • Le quatrième est l'entity factory.


Les animations :

Le constructeur de la classe odfaeg::graphic::Anim attend 4 paramètres :

  • le taux de rafraichissement.
  • la position de l'animation.
  • la taille de l'animation.
  • l'entity factory.
  • Le dernier paramètre est un pointeur vers une entité parente. (null par défaut)
La méthode setInterpolationLevel permet de modifier le niveau d'interpolation de l'animation.
La méthode addFrame permet d'ajouté une frame à l'animation.
Il est possible d'ajouter une animation enfant d'une autre animation, dans ce cas, les frames des animations
enfant seront changée en même temps que celles des animations parents.
Ceci est utile dans le cas des animations squelettique, si par exemple, vous avez un personnage et un pantalon,
et vous souhaiter que les frames et les sommets de l'animation des jambes pantalon changent en même temps que celles de l'animation des jambes
du personnage. Les animations parentes et enfant doivent alors avoir le même nombre de frames.


Les lumières ponctuelles :
Avec ODFAEG les lumières ne sont rien d'autre que des formes dont le dégradé est calculé en fonction de différent paramètres qui sont :

  • La normalmap de la vue.
  • La bumpmap des matériaux.
  • La distance par rapport à la source lumineuse.
  • Les composantes spéculaires des matériaux.
Le constructeurs de la classe odfaeg::graphic::g2d::PonctualLight attend plusieurs paramètre.
-Le premier est le centre de la lumière.
-Les trois suivants sont les rayons en x, y et z de la lumière.
-Le suivant est l'intensité de la lumière.
-Le suivant est la couleur de la lumière.
-Le suivant est la qualité de la lumière.
-L'avant dernier est l'entity factory.
-Et le dernier est un pointeur vers une entité parente. (null par défaut)

Créer des entités :
Pour créer une (par exemple une tile) vous devez utiliser la factory comme ceci en appelant la méthode make_entity, celle-ci prend un paramètre template :
le type d'entité que vous souhaiter créer, il vous suffit ensuite de passer les paramètres de la classe tile à la méthode make_entity.
entityFactory.make_entity(tm.getResourceByAlias("WATER"), Vec3f(0, 0, 0), Vec3f(120, 60, 0),sf::IntRect(0, 0, 100, 50), entityFactory)

Ajouter une entité au monde :
Pour celà il suffit de récupérer le monde de l'application et d'appelé la méthode addEntity comme ceci : 
w = entityFactory.make_entity(entityFactory.make_entity(tm.getResourceByAlias("WALLS"), Vec3f(0, 0, 0), Vec3f(100, 100, 0), sf::IntRect(100, 200, 100, 100), entityFactory),g2d::Wall::TOP_LEFT, &g2d::AmbientLight::getAmbientLight(), entityFactory);
            w->getChildren()[0]->getFace(0)->getMaterial().setTexId("WALLS");
            w->setPosition(Vec3f(0, 130, 130 + w->getSize().y * 0.5f));
            w->setLayer(1);
            getWorld()->addEntity(w);
Voila maintenant vous savez comment créer ces différentes entités par défaut afin de les afficher dans
la fenêtre de rendu.
Cependant ceci ne sera pas optimal car vous risquer d'afficher des entités qui ne sont pas visible.