// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#ifndef NL_VIEW_RENDERER_H
#define NL_VIEW_RENDERER_H

#include "nel/misc/types_nl.h"
#include "nel/3d/u_texture.h"
#include "nel/3d/u_text_context.h"
#include "nel/3d/u_driver.h"
#include "nel/misc/rgba.h"
#include "nel/misc/uv.h"
#include "nel/3d/frustum.h"
#include "../ingame_database_manager.h"


//the NEL 3d driver
extern NL3D::UDriver* Driver;

//the NEL 3d textcontext
extern NL3D::UTextContext *TextContext;

//the network database node
extern CCDBSynchronised IngameDbMngr;


// ***************************************************************************
#define	VR_NUM_LAYER	32
#define	VR_BIAS_LAYER	(VR_NUM_LAYER/2)
#define	VR_LAYER_MAX	(VR_NUM_LAYER-VR_BIAS_LAYER-1)
#define	VR_LAYER_MIN	(-VR_BIAS_LAYER)

// ***************************************************************************
/**
 * class rendering the views
 * All the quads of the interface are displayed in the following order
 *
 *  3--2
 *  |  |
 *  0--1
 *
 * \author Matthieu 'TrapII' Besson
 * \author Nevrax France
 * \date 2002
 */
class CViewRenderer
{
public:
	enum	TSystemTexture
	{
		QuantityCrossTexture= 0,
		DefaultBrickTexture,
		DefaultItemTexture,
		ItemPlanTexture,
		SkillTexture,
		ItemEnchantedTexture,
		DragCopyTexture,
		ItemWornedTexture,
		OutOfRangeTexture,
		RegenTexture,
		RegenBackTexture,
		GlowStarTexture,
		NumSystemTextures,		
	};


public:

	/** That class hold a texture id. It handle texture id destruction.
	*	Please use this class in your view and not sint32 to hold a texture id
	*/
	class CTextureId
	{
	public:

		// Default constructor
		CTextureId ()
		{
			_TextureId = -2;
		}

		// Destructor call deleteTextureId;
		~CTextureId ();

		// Set the texture id
		bool setTexture (const char *textureName, sint32 offsetX = 0, sint32 offsetY = 0, sint32 width = -1, sint32 height = -1,
						bool uploadDXTC=true, bool bReleasable=true);

		// Convert in texture id
		operator sint32 () const
		{
			return _TextureId;
		}

		void serial(NLMISC::IStream &f);

	private:
		sint32	_TextureId;
	};

	/**
	 * destructor
	 */
	CViewRenderer ();
	/**
	 * destructor
	 */
	~CViewRenderer ();

	/// init when TextContext and Driver are created
	void init();

	/// set the driver render states for the interface
	void setRenderStates ();

	/// Delete all textures and the like and reset the view renderer
	void reset();

	/*
	 * setClipWindow : set the current clipping window
	 * (this window do not inherit properties from parent or whatever)
	 */
	void setClipWindow (sint32 x, sint32 y, sint32 w, sint32 h);

	/*
	 * getClipWindow : get the current clipping region
	 */
	void getClipWindow (sint32 &x, sint32 &y, sint32 &w, sint32 &h)
	{
		x = _ClipX;
		y = _ClipY;
		w = _ClipW;
		h = _ClipH;
	}

	/*
	 * true if the clipping region is empty: clipW or clipH is <=0
	 */
	bool isClipWindowEmpty() const {return _ClipW<=0 || _ClipH<=0;}

	/*
	 * checkNewScreenSize : check if the opengl screen size. This is SLOW !
	 * NB: if the window is minimized (w==h==0), then the old screen size is kept, and isMinimized() return true
	 */
	void checkNewScreenSize ();

	/*
	 * getScreenSize : get the screen window size changed (at last checkNewScreenSize called)
	 */
	void getScreenSize (uint32 &w, uint32 &h);

	/*
	 * get OOW / OOH
	 */
	void getScreenOOSize (float &oow, float &ooh);

	/*
	 * is the Screen minimized?
	 */
	bool isMinimized() const {return _IsMinimized;}

	/*
	 * drawBitmap : this is the interface with all the views
	 *
	 */
	void drawRotFlipBitmap (sint layerId, sint32 x, sint32 y, sint32 width, sint32 height, uint8 rot, bool flipv,
					sint32 nTxId, const NLMISC::CRGBA &col = NLMISC::CRGBA(255,255,255,255));

	/*
	 *	Draw a simple wired quad. No flushing is done as the draw is done instantly (usually for debug)
	 */
	void drawWiredQuad(sint32 x, sint32 y, sint32 width, sint32 height, NLMISC::CRGBA col = NLMISC::CRGBA::White);

	/*
	 *	Draw a simple filled quad. No flushing is done as the draw is done instantly (usually for debug)
	 */
	void drawFilledQuad(sint32 x, sint32 y, sint32 width, sint32 height, NLMISC::CRGBA col = NLMISC::CRGBA::White);

	/*
	 * drawBitmap : Tiled version
	 * \param tileOrigin 2 bits 1 - Left/Right (0/1) 2 - Bottom/Top (0/1) (0-BL)(1-BR)(2-TL)(3-TR)
	 *
	 */
	void drawRotFlipBitmapTiled (sint layerId, sint32 x, sint32 y, sint32 width, sint32 height, uint8 rot, bool flipv,
								 sint32 nTxId, uint tileOrigin, const NLMISC::CRGBA &col = NLMISC::CRGBA(255,255,255,255));



	/*
	 * drawBitmap : draw a bitmap roted by 90 degrees in CW 'rot times'
	 *				flipv is a boolean that indicates if there is a vertical flip
	 *				this is a 1:1 ratio so if texture is x long there are x pixels on screen
	 */
	void draw11RotFlipBitmap (sint layerId, sint32 x, sint32 y, uint8 rot, bool flipv, sint32 nTxId,
								const NLMISC::CRGBA &col = NLMISC::CRGBA(255,255,255,255));

	/** Draw an arbitrary quad (fast version) , possibly clipping it. Unlike draw11RotFlipBitmap & the like, texture is filtered here.
	  * quads are all batched in the same render layer
	  */
	void drawQuad(sint layerId, const NLMISC::CQuadUV &quadUV, sint32 nTxId,
				  NLMISC::CRGBA col, bool additif, bool filtered = true);
	/** Draw a set of untextured triangle in the given layer. all triangles of the same layer are batched
	  */
	void drawUnclippedTriangles(sint layerId, const std::vector<NLMISC::CTriangle> &tris, NLMISC::CRGBA col);

	/*
	 *	Draw a text
	 */
	void drawText (sint layerId, float x, float y, uint wordIndex, float xmin, float ymin, float xmax, float ymax, NL3D::UTextContext &textContext);

	/*
	 * loadTextures : load all textures associated with the interface
	 *				this function add a globaltexture to the vector of global textures
	 */
	void loadTextures (const std::string &textureFileName, const std::string &uvFileName, bool uploadDXTC);

	/*
	 *	createTexture : create a texture for the interface, possibly from an externally created texture
	 *  If no external texture is given, then 'sGlobalTextureName' is the filename of the big texture
	 *  You should call deleteTexture when the texture is not used anymore
	 *	The method returns the texture id of the new texture
	 */
	sint32 createTexture (const std::string &sGlobalTextureName, // unique id identifying this big texture, (its filename if not externally created)
						  sint32 offsetX = 0,
						  sint32 offsetY = 0,
						  sint32 width = -1,
						  sint32 height = -1,
						  bool uploadDXTC=true,
						  bool bReleasable=true
						 );


	// change position of a sub-texture (inside its big texture) from the sub-texture filename
	void updateTexturePos(const std::string &texturefileName,
						  sint32 offsetX = 0,
						  sint32 offsetY = 0,
						  sint32 width = -1,
						  sint32 height = -1
						 );

	/** Add / change a global texture from an externally created texture
	  * \param defaultTexWidth width to used when CTextureId::createTexture is used without giving the width (e.g width = -1), useful for cropped textures
	  * \param defaultTexHeight height to used when CTextureId::createTexture is used without giving the height (e.g height = -1), useful for cropped textures
	  */

	void setExternalTexture(const std::string &sGlobalTextureName,
							NL3D::UTexture	*externalTexture = NULL,
							uint32			 externalTexWidth = 1,
							uint32			 externalTexHeight = 1,
							uint32			 defaultTexWidth = 1,
							uint32			 defaultTexHeight = 1
						   );

	/*
	 *	deleteTexture : create a texture for the interface
	 */
	void deleteTexture (sint32 textureId);

	// get a global texture pointer from its name
	NL3D::UTexture		*getGlobalTexture(const std::string &name);

	/*
	 * Flush all parsed view and computed strings to screen
	 */
	void flush ();

	/**
	 * get a texture file pointer from a string name. O(logN)
	 * \param id : the id of the texture
	 * \return a texture file pointer. -1 if not found or if sName is empty()
	 */
	sint32 getTextureIdFromName (const std::string &sName) const;
	std::string getTextureNameFromId (sint32 TxID);
	void getTextureSizeFromId (sint32 id, sint32 &width, sint32 &height);
	NLMISC::CRGBA getTextureColor(sint32 id, sint32 x, sint32 y);


	/**
	 * \return the texture associated with the param figur
	 */
	sint32 getFigurTextureId(uint index)
	{
		nlassert(index < 10);
		return _IndexesToTextureIds[index];
	}

	/**
	 * \return the texture for figur separator '-'
	 */
	sint32 getFigurSeparator() const { return _FigurSeparatorTextureId; }

	sint32 getFigurTextureW() const {return _WFigurTexture;}
	sint32 getFigurTextureH() const {return _HFigurTexture;}
	sint32 getFigurSeparatorW() const {return _WFigurSeparatorTexture;}
	sint32 getFigurSeparatorH() const {return _HFigurSeparatorTexture;}


	sint32 getFigurBlankTextureId ()
	{
		return _FigurBlankId;
	}
	sint32 getBlankTextureId ()
	{
		return _BlankId;
	}


	sint32 getTypoTextureW(char c);
	sint32 getTypoTextureH(char c);
	sint32 getTypoTextureId(char c);

	/// System Texture Manager. Used to avoid storing an id in each Ctrl for some texture code is aware of
	// @{
	sint32	getSystemTextureId(TSystemTexture e) const {return _SystemTextures[e].Id;}
	sint32	getSystemTextureW(TSystemTexture e) const {return _SystemTextures[e].W;}
	sint32	getSystemTextureH(TSystemTexture e) const {return _SystemTextures[e].H;}
	// @}

	/// For string rendering, get the RenderBuffer to the specified layer
	NL3D::URenderStringBuffer		*getStringRenderBuffer(sint layerId);


	/** Custom Rendering Interface
	 * Note that this function is EXTREMLY SLOW so it should be used with care
	 * This function flush the quad cache, clip the quad passed with current clipping region
	 * and draw (with drawQuedUV2) it with the material passed in parameter. There is no cache operation done.
	 * uv used are from (0,0) -> (1,1) for the 2 stages
	 */
	void drawCustom (sint32 x, sint32 y, sint32 width, sint32 height, NLMISC::CRGBA col, NL3D::UMaterial Mat);
	// Same but we can control uv mapping of first stage
	void drawCustom (sint32 x, sint32 y, sint32 width, sint32 height,
					const NLMISC::CUV &uv0Min, const NLMISC::CUV &uv0Max,
					NLMISC::CRGBA col, NL3D::UMaterial Mat);
	// Same but we can control uv mapping of 2 stages
	void drawCustom (sint32 x, sint32 y, sint32 width, sint32 height,
					const NLMISC::CUV &uv0Min, const NLMISC::CUV &uv0Max, const NLMISC::CUV &uv1Min, const NLMISC::CUV &uv1Max,
					NLMISC::CRGBA col, NL3D::UMaterial Mat);

	// **** World space interface methods

	/** Set the current Z in projCenter.z.
	 *	If you want to scale the window position, set a scale!=1. projCenter.x/y  is used as the
	 *	pivot (in window coordinates)
	 */
	void setInterfaceDepth (const NLMISC::CVector &projCenter, float scale);

	// Activate world space transformation
	void activateWorldSpaceMatrix (bool activate);

	// Set the screen to world space matrix
	void setWorldSpaceFrustum (const NL3D::CFrustum &cameraFrustum);

	// Get the current Frustum
	const NL3D::CFrustum &getFrustum () const
	{
		return _CameraFrustum;
	}

private:
	/**
	 * init the map _IndexesToTextures
	 */
	void initIndexesToTextureIds ();
	void initTypo ();

	bool needClipping (const NLMISC::CQuad &q);

	void clip (NLMISC::CQuadColorUV &qout, const NLMISC::CQuadColorUV &qin, uint rot);
	void clip (NLMISC::CQuadColorUV2 &qout, const NLMISC::CQuadColorUV2 &qin);
private:

	// A layer is a vector of Quads.
	class	CLayer
	{
	public:
		// unfiltered quads
		std::vector<NLMISC::CQuadColorUV>	Quads;
		uint32								NbQuads;
		std::vector<NLMISC::CTriangleColorUV>	Tris;
		// filtered alpha blended quads
		std::vector<NLMISC::CQuadColorUV>		FilteredAlphaBlendedQuads;
		// filtered alpha blended tris
		std::vector<NLMISC::CTriangleColorUV>	FilteredAlphaBlendedTris;
		// filtered additif blended quads
		std::vector<NLMISC::CQuadColorUV>		FilteredAdditifQuads;
		// filtered additif blended tris
		std::vector<NLMISC::CTriangleColorUV>	FilteredAdditifTris;

		CLayer()
		{
			NbQuads= 0;
		}
	};

	// SGlobalTexture is a texture that regroup other texture. We store also current quads to render
	struct SGlobalTexture
	{
		SGlobalTexture ()
		{
			FromGlobaleTexture = true;
		}
		uint32				Width, Height;
		uint32				DefaultWidth, DefaultHeight;
		NL3D::UTexture		*Texture;
		std::string			Name;
		bool				FromGlobaleTexture;
		// Array of layers
		CLayer				Layers[VR_NUM_LAYER];
	};

	// For each Layer, store a string Buffer
	NL3D::URenderStringBuffer		*_StringRBLayers[VR_NUM_LAYER];

	// For each Layer, tells if empty or not
	bool							_EmptyLayer[VR_NUM_LAYER];

	// SImage is one texture of the SGlobalTexture textures
	struct SImage
	{
		std::string		Name;
		SGlobalTexture	*GlobalTexturePtr;
		NLMISC::CUV		UVMin, UVMax;

		// Assign UV of this image to a quad depending on the flip and rot
		void setupQuadUV(bool flipv, uint8 rot, NLMISC::CQuadColorUV &dest);
	};

	// ***************************************************************************
	// \name Texture management
	// ***************************************************************************

	// SImage accessors
	SImage	*getSImage(sint32 textureId)
	{
		return &(*(_SImageIterators[textureId]));
	}


	// Add a SImage
	sint32 addSImage(const SImage &image)
	{
		uint i;
		for (i=0; i<_SImageIterators.size(); i++)
		{
			// Free ?
			if (_SImageIterators[i] == _SImages.end())
				break;
		}

		// Nothing free ?
		if (i == _SImageIterators.size())
			_SImageIterators.push_back(_SImages.end());

		_SImages.push_back(image);
		_SImageIterators[i] = _SImages.end();
		_SImageIterators[i]--;
		return (sint32)i;
	}

	// Remove a SImage
	void removeSImage(sint32 textureId)
	{
		// Allocated ?
		nlassert (_SImageIterators[textureId] != _SImages.end());

		// Remove the image
		_SImages.erase (_SImageIterators[textureId]);

		// Remove the index entry
		_SImageIterators[textureId] = _SImages.end();
	}

	typedef std::list<SGlobalTexture>	TGlobalTextureList;
	typedef std::list<SImage>			TSImageList;
	typedef std::vector<std::list<SImage>::iterator>	TSImageIterator;

	// List of global textures
	TGlobalTextureList			_GlobalTextures;

	// List of SImage
	TSImageList					_SImages;

	// Array used to convert a texture ID in _SImages iterator
	TSImageIterator				_SImageIterators;

	// ***************************************************************************

	typedef	std::map<std::string, uint>		TTextureMap;
	TTextureMap					_TextureMap;

	NL3D::UMaterial _Material;

	// Clip & screen system
	sint32 _ClipX, _ClipY, _ClipW, _ClipH;
	float _XMin, _XMax, _YMin, _YMax;

	sint32		_ScreenW, _ScreenH;
	float		_OneOverScreenW, _OneOverScreenH;
	bool		_IsMinimized;


	//map linking a uint to a bitmap. Used to display figurs
	std::vector<sint32> _IndexesToTextureIds;
	sint32				_FigurSeparatorTextureId;
	sint32 _FigurBlankId, _BlankId;
	sint32	_WFigurTexture;
	sint32	_HFigurTexture;
	sint32  _WFigurSeparatorTexture;
	sint32  _HFigurSeparatorTexture;
	NLMISC::CUV		_BlankUV;
	SGlobalTexture	*_BlankGlobalTexture;

	// System textures
	class	CSystemTexture
	{
	public:
		sint32	Id;
		sint32	W;
		sint32	H;

		CSystemTexture()
		{
			Id= -1;
			W= H= 0;
		}
	};
	CSystemTexture		_SystemTextures[NumSystemTextures];

	// Typo texture
	enum
	{
		NumTypoChar= 127,
	};
	sint32				_TypoCharToTextureIds[NumTypoChar];
	sint32				_TypoCharWs[NumTypoChar];
	sint32				_TypoH;


	void	addSystemTexture(TSystemTexture e, const char *s);
	void	initSystemTextures();

	/**
	 * put a new quad in the cache (call flush if texture different)
	 */
	void putQuadInLayer (SGlobalTexture &gt, sint layerId, const NLMISC::CQuadColorUV &qcoluv, uint rot);

	// World space interface methods
	void worldSpaceTransformation (NLMISC::CQuadColorUV &qcoluv);

	bool				_WorldSpaceTransformation;	// Transform into world space
	float				_CurrentZ;					// Current z used for the scene
	NL3D::CFrustum		_CameraFrustum;				// Transform from screen space to world space
	NLMISC::CMatrix		_WorldSpaceMatrix;			// Matrix to be applied for world space transformation
	bool				_WorldSpaceScale;

};


#endif // NL_VIEW_RENDERER_H

/* End of view_renderer.h */