
#ifndef RENDERABLE_ENTITY
#define RENDERABLE_ENTITY

#include <string>
//#include "Renderer.h"		//en commentaire et déplacer dans le .cpp sinon erreur de compilation.
#include "ModelInstance.h"
#include "Frustum.h"

#include "Point2D.h"

#include "DustGenerator.h"

#include "MemoryManager/DebugNew.h"


namespace RenderSystem{

	// forward declaration
	class Renderer;
	/**
	 *	Interface permettant de récupérer les informations nécessaires à l'affichage d'entité sur le terrain. Pour que le renderer affiche
	 * une entitée sur le terrain, on doit passé la classe de l'entitée implémentant cette interface.
	 *
	 * @see ModelInstance pour de plus ample information sur les modeles 3D polygonaux.
	 */
	class RenderableEntity
	{
	public:
		/**
		 * enumeration decrivant toutes les animations que peuvent prendre les unités.
		 */
		enum AnimationType{
			NO_ANIMATION = 0,
			WALK,
			FIGHT,
			WAIT,
			DEATH,
			RIDE,
			RIDEATTACK,
			RIDEWAIT,
			RIDEDEATH,
		};
	private:

		//	on indique que le renderer peut accéder au menbre privé pour une gestion simplifier des modèles enregistrer mais tout aussi
		//efficace et sécurisé.
		friend class Renderer;
	protected:

		/**
		 *	La AABB du model dans le repere global. Cette attribut est seulement utilisé par le renderer.
		 */
		BoundingBox aabb;

		/**
		 * Le modelInstance de cette entitées
		 */
		ModelInstance modelInstance;

		/**
		 * La couleur de l'armée
		 */
		float armyColor[3];

		/**
		 * Permet de savoir si l'unité est dans le frustum ou non
		 */
		bool isVisible;

		/**
		 * Indique si l'unité n'est pas dans du brouillard de guerre
		 */
		bool inFogOfWar;

		/**
		 * le generateur de particules de poussieres
		 */
		ParticleSystem::DustGenerator * dustGenerator;

	public:
		/**
		 * Le constructeur
		 */
		RenderableEntity();

		/**
		 *	Detruit le RenderableEntity. Fait appel a release instance du modeles instancié pour l'affichage.
		 * les modeles doivent donc être détruit après les instances.
		 */
		virtual ~RenderableEntity();

		/**
		 * methode permettant d'initialiser une unitée en fonction de son armee et de son type
		 * @param unitType : appartient à {"Fantassin","FantassinMonte","Piquier","PiquierMonte","Archer","ArcherMonte"}
		 * @param armee : appartient à {"Bleu","Rouge","Neutre"}
		 */
		void setProperties(const std::string& unitType, const std::string& armee);

		/**
		 * methode permettant de definir l'armée a laquel appartient l'unité.
		 * @param army : appartient à {"Bleu","Rouge","Neutre"}
		 */
		void setArmy(const std::string& army);

		/**
		 * Permet d'indiquer si l'unité est dans le brouillard de guerre
		 * Utilisé par le renderer
		 */
		void setFogOfWarVisibility(bool info);

		/**
		 */
		bool isFogOfWarVisible();

		/**
		 * methode permettant de definir la prochaine animation effectuée par l'unité.
		 * @param nextAnimation : la prochaine animation à effectuer.
		 */
		virtual void setAnimation(AnimationType nextAnimation, bool mounted = false);

		/**
		 * methode permettant de recuperer la position de l'entitée affichable.
		 * @return Point2D : la position de l'entitée sur les cases.(sur une case, les coordonnées vont de (0,0) à (1,1) ).
		 */
		virtual Point2D& getRenderableEntityPosition() = 0;

		/**
		 * methode permettant de recuperer l'angle de rotation du model dans le plan (X,Z).
		 * @return float : l'angle en degré.
		 */
		virtual float getRenderableEntityAngle() = 0;

		/**
		 *
		 */
		virtual RenderableEntity::AnimationType getCurrentAnimation();

		virtual void allowDust(bool allow);

		/**
		 * Permet de savoir si l'entité affichable possède de la vie
		 */
		virtual bool haveLife()=0;
		/**
		 * Permet d'obtenir la vie courante de l'entité
		 *
		 * @return la vie courante
		 */
		virtual float getCurrentLife()=0;

		virtual bool isAlive() = 0;

	};

};

#include "MemoryManager/DebugNewOff.h"

#endif


