
#ifndef REGISTRED_TEXTURE
#define REGISTRED_TEXTURE

#ifdef WIN32
#include "windows.h"							//Pour que le compilo ce taisesur exit!
#endif

#include "GL/gl.h"								//OpenGL
#include "GL/glu.h"								//OpenGL

#include "texture2D.h"							//la classe de manipulation de texture2D OpenGL

#include "EXT_texture_filter_anisotropic.h"		//prise encompte des différent filtrage

#include "MemoryManager/DebugNew.h"


namespace RenderSystem
{

	/**
	*	Classe permettant d'utiliser des textures gérer par le TextureManager(voir sont en-tête pour expliction).
	* Cette classe est implémenter pour les différents type de texture OpenGL. Elle implémente le chargement et
	* le relachement des ressources de texture OpenGL. Utile lors d'un changement de qualité graphique ou changement
	* de contexte graphique.
	* @author Hillaire Sébastien
	*/
	class RegistredTexture
	{
	private:

	protected:

		friend class TextureManager;

		/**
		* Le nom de la texture
		*/
		char* name;

		/**
		* Indique le niveau de détail des textures créer (ignorer pour texture 3D)
		*/
		int downSizingLevel;
		/**
		* Indique le mode de filtrage lors de magnification de la texture
		*/
		int magTexFilter;
		/**
		* Indique le mode de filtrage lors de minification de la texture
		*/
		int minTexFilter;
		/**
		* La répétition de texture dur l'axe s
		*/
		int sRepeat;
		/**
		* La répétition de texture dur l'axe t
		*/
		int tRepeat;
		/**
		* La répétition de texture dur l'axe u
		*/
		int uRepeat;
		/**
		* Indique si l'on utilise les mipmap.
		*/
		bool useMipMap;
		/**
		* Le niveau d'anisotropy des objets de textures créer
		*/
		int AnisotropyLevel;

		/**
		* Permet de savoir si la texture en en mémoire vidéo
		*/
		bool isInVideoMemory;

		/**
		*	Permet de charger la texture en mémoire vidéo. Si elle est déjà en mémoire vidéo, elle
		* est automatiquement décharger avant de la recharger avec les paramètre courant.
		*/
		virtual bool loadInVideoMem();

	public:
		/**
		* Constructeur
		*/
		RegistredTexture();
		/**
		* Destructeur
		*/
		~RegistredTexture();

		/**
		* Méthode permettant de régler les propriétés de cette texture.
		*
		* @param downSizingLevel : le niveau de détail (0 meilleur qualité)
		* @param magTexFilter : le filtrage de magnification
		* @param minTexFilter : le filtrage de minification
		* @param AnisotropyLevel : le niveau d'anisotropy appliqué
		* @param _sRepeat : la répetition sur s de la texture
		* @param _tRepeat : la répetition sur t de la texture
		* @param _uRepeat : la répetition sur u de la texture
		*/
		void setProperties(int _downSizingLevel,int _magTexFilter,int _minTexFilter,int _AnisotropyLevel,int _sRepeat,int _tRepeat,int _uRepeat);

		/**
		* Permet d'affecter le nom de la texture(effectue une copie de la chaine).
		*
		* @param _name : la chaine contenant le nom
		*/
		void setName(const char* _name);
		/**
		* Permet d'accéder au nom de la texture.
		*
		* return le nom
		*/
		inline const char* getName()
		{
			return this->name;
		}

		/**
		* permet de savoir si la texture est en mémoire vidéo
		*
		* @return true si la texture est en mémoire vidéo
		*/
		inline bool isInVideoMem()
		{
			return this->isInVideoMemory;
		}


		/**
		* Permet d'accéder à l'objet de type Texture correspondant
		*
		* @return return la Texture correspondante à cette RegistredTexture
		*/
		virtual Texture* getTexture();

		/**
		* permet d'accéder au type de la texture OpenGL
		*
		* @return le type de la texture OpenGL
		*/
		virtual unsigned int getTarget();
		/**
		* permet d'accéder à l'id de la texture OpenGL
		*
		* @return l'id de la texture OpenGL
		*/
		virtual unsigned int getId();
		/**
		* permet de sélectionner la texture comme texture active
		*
		*/
		virtual void bindTexture();
		/**
		* permet d'activer le type de texture pour l'unité de texture courante
		*/
		virtual void glEnableTexture();
		/**
		* permet de désactiver le type de texture pour l'unité de texture courante
		*/
		virtual void glDisableTexture();

		/**
		* Permet de libérer la mémoire vidéo utilisé par la texture 
		*/
		virtual void unloadFromVideoMem();
	};


	/**
	*	Une texture 2D gérer par le manager de texture.
	*		- this->name indique le chemin de la texture(bmp ou tga).
	*		- this->alphaMap : texture d'alpha.
	*/
	class RegistredTexture_2D : public RegistredTexture
	{
	private:

		/**
		*	pointe sur un chaine de caractère si on veut mettre cette texture dans le canal alpha(composante rouge).
		* 
		* ATTENTION: doit être mis a null si on ne veut pas l'utilisé sinon le pointeur est utilisé pour chargement.
		*/
		char* alphaMap;

	protected:

		friend class TextureManager;

		/**
		*	La texture 2D enregistré
		*/
		Texture2D tex2d;
		
		/**
		*	Permet de charger la texture en mémoire vidéo. Si elle est déjà en mémoire vidéo, elle
		* est automatiquement décharger avant de la recharger avec les paramètre courant.
		*/
		bool loadInVideoMem();
		/**
		* Permet de libérer la mémoire vidéo utilisé par la texture 
		*/
		void unloadFromVideoMem();

	public:

		//TODO a bien commenté
		/**
		* Indique si l'on doit génerer un canal alpha
		*/
		bool generateAlpha;
		unsigned char rBlended;
		unsigned char gBlended;
		unsigned char bBlended;
		unsigned char alphaBlendValue;
		unsigned char alphaDefault;

		/**
		* Constructeur
		*/
		RegistredTexture_2D();
		/**
		* Destructeur
		*/
		~RegistredTexture_2D();

		/**
		* Permet d'affecter le nom de la texture d'alpha(effectue une copie de la chaine).
		* NULL pour ne pas la prendre en compte
		*/
		void setAlphaMap(const char* _alphamap);
		/**
		* Permet d'accéder au nom de la texture d'alpha.
		*/
		inline const char* getAlphaTex()
		{
			return this->alphaMap;
		}

		/**
		* Permet d'accéder à l'objet de type Texture correspondant
		*/
		Texture* getTexture();
		/**
		* permet d'accéder au type de la texture OpenGL
		*
		* @return le type de la texture OpenGL
		*/
		unsigned int getTarget();
		/**
		* permet d'accéder à l'id de la texture OpenGL
		*
		* @return l'id de la texture OpenGL
		*/
		unsigned int getId();
		/**
		* permet de sélectionner la texture comme texture active
		*
		*/
		void bindTexture();
		/**
		* permet d'activer le type de texture pour l'unité de texture courante
		*/
		void glEnableTexture();
		/**
		* permet de désactiver le type de texture pour l'unité de texture courante
		*/
		void glDisableTexture();
	};


};// namespace RenderSystem;

#include "MemoryManager/DebugNewOff.h"

#endif