
#ifndef RENDERER
#define RENDERER

#include "stdlib.h"

#ifdef WIN32
#include <windows.h>
#endif
#include <GL/GL.h>
#include <GL/glut.h>

#include "math_lib.h"

#include "Case.h"
#include "GroundMap.h"
#include "GroundZone.h"
#include "ZoneManager.h"

#include "TextureManager.h"
#include "Frustum.h"
#include "Model.h"
#include "ModelMD2.h"
#include "ModelStatic.h"
#include "ModelInstance.h"
#include "RenderableEntity.h"
#include "MiniMap.h"
#include "glFont2D.h"

#include "Army.h"

#include "ParticleEngine.h"
#include "ParticleManager.h"
#include "ParticleDrawer.h"
#include "BloodGenerator.h"
#include "FireGenerator.h"
#include "FishGenerator.h"
#include "LuciolGenerator.h"
#include "LuciolParticle.h"
#include "RainGenerator.h"
#include "RainParticle.h"
#include "smokeGenerator.h"
#include "DustGenerator.h"
#include "snowGenerator.h"
#include "DirectionalParticle.h"

#include "MemoryManager/DebugNew.h"



/**

glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
// now glColor* changes diffuse reflection 
glColor3f(0.2, 0.5, 0.8);
// draw some objects here 
glColorMaterial(GL_FRONT, GL_SPECULAR);
// glColor* no longer changes diffuse reflection 
// now glColor* changes specular reflection 
glColor3f(0.9, 0.0, 0.2);
// draw other objects here 
glDisable(GL_COLOR_MATERIAL);


**/



#define	QT_MIN_SIDE_SIZE		8			//la taille minimum d'une carte (et d'une feuille du quad tree)
#define	FOG_DISTANCE			64.0f*1.2f*CASE_SIDE_SIZE//la distance du brouillard


// TODO : bool d'affichage des feuilles et/ou des troncs
// TODO : finir affichage des renderableEntities

namespace RenderSystem{

	/**
	*	Une noeud du QuadTree utilisé pour optimisé l'affichage
	*/
	struct QT_Node
	{
		/**
		 * Les sous chemin possible
		 */
		QT_Node*				sons_node[4];

		/**
		 * Le pavé de visibilité à tester
		 */
		BoundingBox					bb;

		/**
		 * true si ce noeud est en fait une feuille de l'arbre
		 */
		bool isLeaf;

		/**
		 *  MEADOW
		 */
		unsigned short* groundMeadowElement;
		/**
		 *
		 */
		unsigned int nbGroundMeadowElement;
		/**
		 *  FOREST
		 */
		unsigned short* groundForestElement;
		/**
		 *  FOREST
		 */
		unsigned int nbGroundForestElement;
		/**
		 * OREE
		 */
		unsigned short* groundOreeElement;
		/**
		 * OREE
		 */
		unsigned int nbGroundOreeElement;
		/**
		 * WATER
		 */
		unsigned short* groundWaterElement;
		/**
		 * WATER
		 */
		unsigned int nbGroundWaterElement;
		/**
		 * ROAD
		 */
		unsigned short* groundRoadElement;
		/**
		 * ROAD
		 */
		unsigned int nbGroundRoadElement;

		/**
		 * La display list de rendu de l'eau
		 */
		unsigned int waterDL;
		/**
		 * La display list de rendu du tronc des arbres
		 */
		unsigned int tree_trunkDL;
		/**
		 * La display list de rendu des feuilles des arbres
		 */
		unsigned int tree_leafDL;

		/**
		* L'origine du noeud sur l'axe X
		 * Valide seulement pour les feuilles
		*/
		int oX;
		/**
		* L'origine du noeud sur l'axe Z
		 * Valide seulement pour les feuilles
		*/
		int oZ;
		/**
		 * La taille du noeud sur l'axe X
		 * Valide seulement pour les feuilles
		*/
		int sX;
		/**
		* La taille du noeud sur l'axe Z
		 * Valide seulement pour les feuilles
		*/
		int sZ;
	};
	
	/**
	 *	Permet de représenter un plan
	 */
	struct Plane
	{

		/**
		 * la coordonnée de la normal
		 */
		float n[3];

		/**
		 * composante 'd' de l'équation du plan ax+by+cz+d
		 */
		float d;
	};
	/**
	 * Permet de représenter un case de la map : composé de 2 plans.
	 */
	struct MapCasePlanes
	{
		/**
		 * le plan du triangle haut-droit de la case
		 */
		Plane p1;
		/**
		 * le plan du triangle bas-gauche de la case
		 */
		Plane p2;
	};


	/**
	 *	La classe représentant permettant de rendre le terrain a l'écran depuis un point de vue donnée de manière
	 * optimisé et rapide.
	 *	Cette classe implémente un pattern SINGLETON.
	 */
	class Renderer
	{
	private:

		/**
		 * L'unique instance du ZoneManager dans le jeu
		 */
		static Renderer* renderer;

		/**
		 * Le constructeur par défaut privé
		 */
		Renderer();

		/**
		 * destructeur privé
		 */
		~Renderer();

		/**
		 * la position du joueur dans le repere global.
		 * @see : Renderer::render (copie du dernier paramètre)
		 */
		float pos[3];
		/**
		 * Le frustum de vision courant pour permettre l'optimisation de l'affichage.
		 * @see : Renderer::render (copie du dernier paramètre)
		 */
		Frustum f;
		/**
		 * Le temp écouler depuis le dernier calcul de visibilité de la map(brouillard de guerre)
		 */
		float visibilityElapsedTime;
		/**
		 * Le temp a atteindre  pour recalculer la visibilité de la map(brouillard de guerre)
		 */
		float visibilityUpdateTime;

		/**
		 * L'intensité de la couleur du terrain découvert
		 */
		float groundSeenColorIntensity;
		/**
		 * L'intensité de la couleur du terrain en brouillard de guerre
		 */
		float groundWarFogColorIntensity;
		/**
		 * La couleur de l'eau
		 */
		float waterColor[3];
		/**
		 * La translation de l'eau
		 */
		float trWater;

		/**
		 * La couleur du brouillard
		 */
		float fogcolor[4];

		/**
		 * Le vector contenant les feuilles visible du quad-tree à chaque frame
		 */
		std::vector<QT_Node*> visibleLeaf;

		/**
		 * Le model du tronc de l'arbre
		 */
		ModelStatic* treeTrunkModel;
		/**
		 * Le model des feuilles de l'arbre
		 */
		ModelStatic* treeLeafModel;
		/**
		 * L'instance du model du tronc de l'arbre
		 */
		ModelInstance* treeTrunkInstance;
		/**
		 * L'instance du model des feuilles de l'arbre
		 */
		ModelInstance* treeLeafInstance;

		/**
		 * la map contenant l'ensemble des models d'unitées
		 */
		std::map<std::string,Model*> modelsMap;

		/**
		 * Le moteur de pluie
		 */
		ParticleSystem::ParticleEngine* rain;
		/**
		 * Le moteur de neige
		 */
		ParticleSystem::ParticleEngine* snow;
		/**
		 * Le moteur de particule d'environement courant
		 */
		ParticleSystem::ParticleEngine* curEnvPE;
		/**
		 *
		 */
		ParticleSystem::ParticleDrawer particleDrawer;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine::ParticlePhysique*> vent;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> lucioleEngine;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> fireEngine;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> fishEngine;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> springEngine;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> bloodEngine;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> sparkEngine;
		/**
		 *
		 */
		std::vector<ParticleSystem::ParticleEngine*> dustEngine;
		/**
		 *
		 */
		float windTime;

		/**
		 * La map contenant les entitées affichables. La clé est l'adresse de la classe.
		 */
		std::map<RenderableEntity* ,RenderableEntity*> renderableEntities;
		/**
		 * La map contenant les decors affichables. La clé est l'adresse de la classe.
		 */
		std::map<RenderableEntity* ,RenderableEntity*> decors;

		/**
		 * la minimap.
		 */
		MiniMap miniMap;

		/**
		 * pour afficher des chaine de caractère à l'écran
		 */
		glFont2D glfont;

		Army* army1;
		Army* army2;
		/**
		 * l'armé suivi. Si currentArmy==NULL, on suit les deux armées : pas de brouillard de guerre affiché
		 */
		Army* currentArmy;

		/**
		 * Indique si une GroundMap est chargé
		 */
		bool mapIsLoaded;
		/**
		 * Permet de rendre la mémoire utilisé par les zones
		 */
		void unloadGroundMap();

		/**
		 * Permet de suprimer le quadTree de la mémoire. C'est une fonction récursive.
		 */
		void rec_deleteQuadTree(QT_Node *qtnode);

		/**
		 * Fonction récursive construisant le quad-tree.
		 *
		 * @param oX : l'origine de qtnode sur l'axe X
		 * @param oZ : l'origine de qtnode sur l'axe Z
		 * @param sX : la taille de qtnode sur l'axe X
		 * @param sZ : la taille de qtnode sur l'axe Z
		 * @param qtnode : le noeud que l'on va calculer
		 */
		void rec_buildQuadTree(int oX, int oZ, int sX, int sZ, QT_Node *qtnode);

		/**
		 *	Permet de tester les feuilles du quad-tree pour vérifier leur présence dans le frustum de vue. Affiche aussi
		 * les noeuds et feuilles du quad-tree si la variable showQuadTree vaut true.
		 *
		 * @param qt : le pointeur sur le noeud du quadTree à tester.
		 * @param forceVisible : permet de forcer les sous-noeud de ce noeud à visible pour limiter les calculs
		 */
		void rec_ComputeVisMap(QT_Node* qt, bool forceVisible=false);

		/**
		 * Fonction récursive permettant de compiler les display list OpenGL pour chaque feuille
		 *
		 * @param qtnode : le noeud que l'on va calculer
		 */
		void rec_buildOpenGLDisplayList(QT_Node *qtnode);

		/**
		 * Fonction récursive permettant d'effacer les display list OpenGL pour chaque feuille
		 *
		 * @param qtnode : le noeud que l'on va calculer
		 */
		void rec_deleteOpenGLDisplayList(QT_Node *qtnode);

		/**
		 *	Permet de rendre toutes les surfaces d'une parcelle de terrain.(mais pas l'effet d'eau par exemple)
		 *
		 * @param qtnode : le noeud que l'on va calculer
		 */
		void renderGroundForDL(QT_Node *qtnode);

		/**
		 *	Permet de rendre les vertices et coordonnée de texture d'une parcelle de terrain si la case
		 * est de type WATER. L'offset pour l'eau n'est pris en compte car l'eau est en surface.
		 *
		 * @param oX : l'origine de la parcelle sur l'axe X
		 * @param oZ : l'origine de la parcelle sur l'axe Z
		 * @param sX : la taille de la parcelle sur l'axe X
		 * @param sZ : la taille de la parcelle sur l'axe Z
		 */
		void renderWaterForDL(int oX, int oZ, int sX, int sZ);

		/**
		 *	Permet de rendre les vertices,normal et coordonnée de texture d'une parcelle de terrain si la case
		 * est de type de terrain t. L'offset pour l'eau est pris en compte.
		 *
		 * @param t : le type de terrain rechercher
		 */
		void renderGroundWithTexture(ground::GroundType t,unsigned int* nbEl, unsigned short** elem,int oX, int oZ, int sX, int sZ);


		/**
		 *	Indique si une parcelle rectangulaire de la map contient un type de texture.
		 *
		 * @param t : le type de terrain rechercher
		 * @param oX : l'origine de la parcelle sur l'axe X
		 * @param oZ : l'origine de la parcelle sur l'axe Z
		 * @param sX : la taille de la parcelle sur l'axe X
		 * @param sZ : la taille de la parcelle sur l'axe Z
		 */
		bool containsGroundWithTexture(ground::GroundType t,int oX, int oZ, int sX, int sZ);

		/**
		 *  Calcul l'offset de hauteur du vertex de coordonnée dans la matrice de vertex (x,y) suivant le faites
		 * que la case soit immergées ou non.
		 *
		 * @param x : coordonnée x dans la matrice de vertices
		 * @param y : coordonnée y dans la matrice de vertices
		 */
		float vertexWithWaterLevelOffset(int i, int j);

		/**
		 * Calcul la hauteur du vertex de coordonnée dans la matrice de vertex (x,y) suivant les cases adjacentes.
		 *
		 * @param x : coordonnée x dans la matrice de vertices
		 * @param y : coordonnée y dans la matrice de vertices
		 */
		float computeHauteur(int x,int y);

		/**
		 *	Permet d'afficher un model en utilisant ces vertex, coordonnée de texture et normal avec la matrice modelView
		 * courante. Cette fonction ne s'occupe pas d'activer la texture du model instance et les tableaux OpenGL.
		 *
		 * @param mi : l'instance a afficher
		 */
		void Renderer::renderModel(ModelInstance* mi);

		/**
		 *	Permet d'afficher les arbres situer sur une feuille du quad-tree dans une displayList
		 *  Cette fonction ne s'occupe pas d'activer les tableaux OpenGL.
		 *
		 * @param qt : le noeud a traiter
		 */
		void renderQTLeafTreeDL(QT_Node* qt);

		/**
		 * Permet d'afficher une zone à l'écran
		 *
		 * @param z : la zone a afficher
		 */
		void renderGroundZone(ground::GroundZone* z);

		/**
		 * Permet d'utiliser les différents affichages pour débugguer les zones.
		 */
		void debugZone();

		/**
		 * Permet de (re)charger les textures en mémoire d'un tileset particulier
		 *
		 * @param tileSet : un pointeur sur la chaine de caractère représentant le nom du dossier du tileSet sur le HDD.
		 */
		void reloadTexture(char* tileSet);


		/**
		 *
		 */
		void renderGround();
		/**
		 *
		 */
		void renderWater();
		/**
		 *
		 */
		void renderTree();
		/**
		 *
		 */
		void renderModel();
		/**
		 *
		 */
		void renderDecor();
		/**
		 *
		 */
		void renderParticle();
		/**
		 *
		 */
		void renderEntitiesLife();


	protected:

		/**
		 * Le pointeur sur les vertices de la map
		 */
		float* vertex;
		/**
		 * Le pointeur sur les couleurs des vertices de la map
		 */
		float* color;
		/**
		 * Le pointeur sur le tableau de coordonnée de texture
		 */
		float* texCoord;
		/**
		 * Le pointeur sur le tableau des normal de chaque vertex
		 */
		float* normal;

		/**
		 * Le temps écouler depuis la dernière frame
		 */
		float elapsedTime;

		/**
		 * Le pointeur sur les plan de la surface de la map
		 */
		MapCasePlanes* mapPlanes;

		/**
		 * La racine du quad tree
		 */
		QT_Node *qtRoot;

		/**
		 * La texture de prairie
		 */
		RegistredTexture* texMeadow;
		/**
		 * La texture de foret
		 */
		RegistredTexture* texForest;
		/**
		 * La texture de l'oree de la foret
		 */
		RegistredTexture* texOreeForest;
		/**
		 * La texture de chemin
		 */
		RegistredTexture* texRoad;
		/**
		 * La texture de fond de l'eau
		 */
		RegistredTexture* texUnderWater;
		/**
		 * La texture de l'eau
		 */
		RegistredTexture* texWater;
		/**
		 * La texture du tronc
		 */
		RegistredTexture* texTreeTrunk;
		/**
		 * La texture des feuilles
		 */
		RegistredTexture* texTreeLeaf;
		/**
		 * La texture des lucioles
		 */
		RegistredTexture* texLuciole;
		/**
		 * La texture de la neige
		 */
		RegistredTexture* texSnow;
		/**
		 * La texture du feu
		 */
		RegistredTexture* texFire;
		/**
		 * La texture des poissons
		 */
		RegistredTexture* texFish;
		/**
		 * La texture des fontaines
		 */
		RegistredTexture* texSpring;
		/**
		 * La texture du sang
		 */
		RegistredTexture* texBlood;
		/**
		 * La texture d'etincelle
		 */
		RegistredTexture* texSpark;
		/**
		 * La texture d'etincelle
		 */
		RegistredTexture* texDust;

		/**
		 * Les cases du terrain courant
		 */
		ground::Case*** gc;
		/**
		 * La largeur courante du terrain
		 */
		int gw;
		/**
		 * La hauteur courante du terrain
		 */
		int gh;
		/**
		 * La largeur courante du terrain en nombre de vertex
		 */
		int gvw;
		/**
		 * La hauteur courante du terrain en nombre de vertex
		 */
		int gvh;

	public:

		/**
		 *	Permet d'avoir accès à l'unique instance du Renderer
		 *
		 * @return l'unique Renderer
		 */
		static Renderer& getInstance();

		/**
		 *	Permet de détruire l'unique instance du Renderer
		 *
		 * @return l'unique Renderer
		 */
		static void destroy();

		/**
		 *	Permet de connaitre le terrain a rendre. Ici, nous allons calculer la géometrie du terrain et le quadtree 
		 * associé.
		 *	Assigne NULL à la matrice de visibilité : il faut en respécifier une autre.
		 *
		 * @param t : le terrain dont on doit calculer les zone et axes.
		 */
		void loadGroundMap(ground::GroundMap& t, char* tileSet, Army& a1, Army& a2);

		/**
		 * Permet de changer les tileset pour changer le style d'affichage de l'environnement
		 *
		 * @pre : le tileSet doit existé sur le disque. Aucune vérification n'est faite
		 */
		void changeTileSet(char* tileSet);

		//////////////////////////////
		////////// LE RENDU //////////
		//////////////////////////////

		/**
		 *	Permet d'initialiser la phase de rendu. A appelé obligatoirement avant la méthode render(...).
		 *	Plusieur appel à la suite de cette méthode peut mettre le moteur en état inconnu : il faut donc ne faire
		 * qu'un seul appel à chaque frame.
		 *
		 * @param time_ms : le temps écoulé de puis la dernière frame en millisecond
		 */
		void beginFrame(float time_ms);

		/**
		 *	Rend le niveau dans le buffer de l'écran depuis le point de vue pos et le frustum de vue f.
		 * La matrice GL_MODELVIEW doit être positionnée(pos et f sont utilisés seulement pour le culling)
		 *
		 * @param pos la position du joueur dans le repere global.
		 * @param frustum Le frustum de vision courant pour permettre l'optimisation de l'affichage.
		 */
		void render(float *pos, Frustum* f);
	
		/**
		 *	Permet d'indiquer au moteur que la phase de rendu est terminé.
		 *
		 *	Plusieur appel à la suite de cette méthode peut mettre le moteur en état inconnu : il faut donc ne faire
		 * qu'un seul appel à chaque frame.
		 */
		void endFrame();

		/**
		 *	Permet de régler le temps d'update du brouillard de guerre
		 *
		 * @param time_ms : le temps d'update en milliseconde. time_ms sera clamper à la plage de valeur [0,2000]
		 */
		void setVisibilityUpdateTime(float time_ms);
		/**
		 *	Permet de récupérer le temps d'update du brouillard de guerre.
		 *
		 * @return : le temps d'update en milliseconde.
		 */
		float getVisibilityUpdateTime();

		/**
		 * Permet de sélectionner l'armé à suivre.
		 *
		 * @param whitch : 0->suivi de l'armé 0, 1->suivi de l'armé 1, 2->suivi des 2 armés
		 */
		void followArmy(int which);

		///////////////////////////
		///////// MODELES /////////
		///////////////////////////

		/**
		 *	Permet d'enregistrer un entitée affichable auprès du moteur d'affichage.
		 *
		 * @param entity : l'entitée que le moteur doit afficher.
		 */
		void addRenderableEntity(RenderableEntity& entity);

		/**
		 *	Permet de supprimer un entitée affichable auprès du moteur d'affichage. Pour savoir quel entité enregistrer on supprime,
		 * on compare les adresses.
		 *
		 * @param entity : l'entitée que le moteur ne doit plus afficher.
		 */
		void removeRenderableEntity(RenderableEntity& entity);
		/**
		 *	Permet d'enregistrer un entitée affichable auprès du moteur d'affichage.
		 *
		 * @param entity : l'entitée que le moteur doit afficher.
		 */
		void addDecor(RenderableEntity& entity);

		/**
		 *	Permet de supprimer un entitée affichable auprès du moteur d'affichage. Pour savoir quel entité enregistrer on supprime,
		 * on compare les adresses.
		 *
		 * @param entity : l'entitée que le moteur ne doit plus afficher.
		 */
		void removeDecor(RenderableEntity& entity);

		//////////////////////////////
		///////// UTILITAIRE /////////
		//////////////////////////////

		/**
		 * Permet de récupérer la vrai hauteur pour un point 2D donné.(la largeur d'une case va de 0.0f a 1.0f)
		 *
		 * @pre : p != NULL
		 * @param pos : la position en 2d sur la carte dont on veut trouver la hauteur.
		 */
		float getElevation(Point2D& pos);
		/**
		 * Permet de récupérer la vrai hauteur pour un point 2D donné.(la largeur d'une case va de 0.0f a 1.0f)
		 *
		 * @param x : la position x en 2d.
		 * @param y : la position x en 2d.
		 */
		float getElevation(float x, float y);

		/**
		 * Permet de récupérer la vrai hauteur pour un point 2D donné.(la largeur d'une case va de 0.0f à CASE_SIDE_SIZE)
		 *
		 * @pre : p != NULL
		 * @param pos : la position en 2d sur la carte dont on veut trouver la hauteur.
		 */
		float getElevationWorldCoord(Point2D& pos);
		/**
		 * Permet de récupérer la vrai hauteur pour un point 2D donné.(la largeur d'une case va de 0.0f a CASE_SIDE_SIZE)
		 *
		 * @param x : la position x en 2d.
		 * @param y : la position x en 2d.
		 */
		float getElevationWorldCoord(float x, float y);

		/**
		 * methode permettant d'initialiser une instance de model en fonction des parametres.
		 */
		void setupModelInstance(ModelInstance& modelInstance,const std::string& type, const std::string& camp);

		/**
		 * methode permettant de definir l'intensitée des cases dans le brouillard et hors brouillrd de guerre.
		 * @param fogIntensity : l'intensitée des cases dans le brouillard
		 * @param visibleIntensity : l'intensitée des cases visibles.
		 */
		void setFogOfWarAttributes(float fogIntensity,float visibleIntensity);

		/**
		 * methode servant à afficher un chemin.
		 * @param path : le chemin à afficher
		 */
		void drawPath(std::vector<Point2D>& path);

		/**
		 * methode permettant d'ajouter un moteur de particules de feu avec sa fumée au renderer
		 * @param fire : le moteur de particules de flammes 
		 * @param smoke : le moteur de particules de fumée.
		 */
		void addFireParticle(ParticleSystem::ParticleEngine* fire,ParticleSystem::ParticleEngine* smoke);
		/**
		 * methode permettant d'ajouter un moteur de particules de fontaineau renderer
		 * @param fire : le moteur de particules de fontaine
		 */
		void addSpringParticle(ParticleSystem::ParticleEngine* spring);

		/**
		 * methode permettant d'ajouter un moteur de particules de sang eau renderer
		 * @param pos : la position du personnage
		 */
		void addBloodParticle(Point2D& pos);

		/**
		 * methode permettant d'ajouter un moteur de particules de particules eau renderer
		 * @param pos : la position du personnage
		 */
		void addSparkParticle(Point2D& pos,bool fatal = false,float radius = 0.0f);
		/**
		 * methode permettant d'ajouter un moteur de particules de poussiere
		 * @param pos : la position du personnage
		 */
		void addDustParticle(ParticleSystem::DustGenerator* generator);

		/**
		 *
		 */
		void setGLFont(glFont2D& glf);

		///////////////////////////////
		////////// DEBUGGAGE///////////
		///////////////////////////////

		/**
		 * Permet de bloquer le frustum de vision du renderer
		 */
		bool skipFrustumUpdate;

		/**
		 * Permet d'afficher les AABB du QuadTree
		 */
		bool showQuadTree;
		/**
		 * booleen permettant de savoir si on doit afficher le graph de zone.
		 */
		bool showGraph;
		/**
		 * Permet d'afficher le sol en wireframe avec les normals
		 */
		bool showWireGround;
		/**
		 * Permet d'afficher la bounding box des particules dans le monde
		 */
		bool showParticleAABB;
		/**
		 * Permet d'afficher la bounding box des omdeles dans le monde
		 */
		bool showModeleWorldAABB;
		/**
		 * Permet d'afficher la bounding box des omdeles dans le monde
		 */
		bool showModeleLocalAABB;
		/**
		 * Permet d'afficher la vie de unité
		 */
		bool showUnitLife;
		
		/**
		 * Permet d'aficher ou non l'effet de l'eau
		 */
		bool renderWaterZone;
		/**
		 * Permet d'aficher ou non l'effet de l'eau
		 */
		bool renderTreeLeaf;
		/**
		 * Permet d'aficher ou non l'effet de l'eau
		 */
		bool renderTreeTrunk;
		/**
		 * permet de savoir si on doit afficher les particules ou pas
		 */
		bool renderParticles;
		/**
		 * Permet d'afficher les unités à travers des arbres
		 */
		bool renderHiddenUnits;
		/**
		 * Permet d'afficher les unités à travers des arbres
		 */
		bool renderDecors;
		/**
		 * Permet d'utilisé ou non du brouillard
		 */
		bool useGLFog;
		/**
		 * Permet d'utilisé ou non l'éclairage OpenGL
		 */
		bool useGLlighting;
		/**
		 * Permet d'utiliser ou non les texture pour le sol
		 */
		bool useGroundTexture;

		/**
		 * Permet d'afficher ou non l'intensité du danger sur certaine case
		 */
		bool showBlockCase;
		/**
		 * Permet d'afficher ou non l'intensité du danger sur certaine case
		 */
		bool showDangerZoneIntensity;
		/**
		 * Permet d'afficher ou non l'intensité du danger sur certaine case
		 */
		bool showStrongZoneIntensity;
		/**
		 * Permet d'afficher ou non l'intensité du danger sur certaine case
		 */
		bool showNaturelAxeIntensity;
		/**
		 * Permet d'afficher une zone forte précise
		 * -1 : désactivé ; autre : on vérifie si l'idientifiant existe et on affiche la zone
		 */
		int showStrongZoneCases;
		/**
		 * Permet d'afficher un axe naturel précis
		 * -1 : désactivé ; autre : on vérifie si l'idientifiant existe et on affiche la zone
		 */
		int showNaturalAxeCases;
		/**
		 * Permet d'afficher une zone de foret précise
		 * -1 : désactivé ; autre : on vérifie si l'idientifiant existe et on affiche la zone
		 */
		int showForestZoneCases;

		/**
		 * Le facteur d'écoulement du temp
		 */
		float timeFactor;

	};

}

#include "MemoryManager/DebugNewOff.h"

#endif

