/***********************************************************************
	filename:	openglrenderer.h
	created:	9/4/2004
	author:		Mark Strom
				mwstrom@gmail.com

	purpose:	Interface to Renderer implemented via Opengl
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _openglrenderer_h_
#define _openglrenderer_h_

#include "CEGUIBase.h"

#if (defined( __WIN32__ ) || defined( _WIN32 )) && !defined(CEGUI_STATIC)
#   ifdef OPENGL_GUIRENDERER_EXPORTS
#       define OPENGL_GUIRENDERER_API __declspec(dllexport)
#   else
#       define OPENGL_GUIRENDERER_API __declspec(dllimport)
#   endif
#else
#   define OPENGL_GUIRENDERER_API
#endif


#if defined(_WIN32)//  All this taken from glut.h
#  ifndef APIENTRY
#   define GLUT_APIENTRY_DEFINED
#   if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) || defined(__LCC__) || defined(__GNUC__)
#    define APIENTRY    __stdcall
#   else
#    define APIENTRY
#   endif
#  endif
/* XXX This is from Win32's <winnt.h> */
#  ifndef CALLBACK
#   if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) || defined(__LCC__) || defined(__GNUC__)
#    define CALLBACK __stdcall
#   else
#    define CALLBACK
#   endif
#  endif
/* XXX Hack for lcc compiler.  It doesn't support __declspec(dllimport), just __stdcall. */
#  if defined( __LCC__ )
#   undef WINGDIAPI
#   define WINGDIAPI __stdcall
#  else
/* XXX This is from Win32's <wingdi.h> and <winnt.h> */
#   ifndef WINGDIAPI
#    define GLUT_WINGDIAPI_DEFINED
#    define WINGDIAPI __declspec(dllimport)
#   endif
#  endif
/* XXX This is from Win32's <ctype.h> */
#  ifndef _WCHAR_T_DEFINED
typedef unsigned short wchar_t;
#   define _WCHAR_T_DEFINED
#  endif
# endif //win32 end glut.h stuff

/* XXX Hack for finding headers in Apple's OpenGL framework. */
#if defined( __APPLE__ )
#include <OpenGL/gl.h>
#include <OpenGL/glu.h>
#else /* __APPLE__ */
#include <GL/gl.h>
#include <GL/glu.h>
#endif /* __APPLE__ */
#include <list>
#include <set>

#include "CEGUIRenderer.h"
#include "CEGUITexture.h"


// #if defined(_WIN32)
// #  if defined(_DEBUG)
// #     pragma comment(lib, "CEGUIBase_d.lib")
// #  else
// #     pragma comment(lib, "CEGUIBase.lib")
// #  endif
// #endif

#if defined(_MSC_VER)
#	pragma warning(push)
#	pragma warning(disable : 4251)
#endif

#define OGLRENDERER_VBUFF_CAPACITY	4096


// Start of CEGUI namespace section
namespace CEGUI
{
  /*************************************************************************
	Forward refs
  *************************************************************************/
  class OpenGLTexture;
  class ImageCodec;
  class DynamicModule;
  
  /*!
    \brief
    Renderer class to interface with OpenGL
  */
  class OPENGL_GUIRENDERER_API OpenGLRenderer : public Renderer
  {
  public:
    /*!
      \brief
      Constructor for OpenGL Renderer object

      \param max_quads
      obsolete.  Set to 0.
      
      \param codec
      A pointer to a user provided image codec. The renderer
      does not take ownership of the codec object. 
    */
    OpenGLRenderer(uint max_quads, ImageCodec* codec = 0);
    /*!
      \brief
      Constructor for OpenGL Renderer object 
      
      \param max_quads
      obsolete. Set to 0.
      
      \param width
      width of the CEGUI viewport.
      
      \param height 
      height of the CEGUI viewport.

      \param codec
      A pointer to a user provided image codec. The renderer
      does not take ownership of the codec object. 
    */
    OpenGLRenderer(uint max_quads,int width, int height, ImageCodec* codec  = 0);


    /*!
      \brief
      Destructor for OpenGLRenderer objects
    */
    virtual ~OpenGLRenderer(void);

    // add's a quad to the list to be rendered
    virtual	void	addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);

    // perform final rendering for all queued renderable quads.
    virtual	void	doRender(void);

    // clear the queue
    virtual	void	clearRenderList(void);


    /*!
      \brief
      Enable or disable the queuing of quads from this point on.

      This only affects queuing.  If queuing is turned off, any calls to addQuad will cause the quad to be rendered directly.  Note that
      disabling queuing will not cause currently queued quads to be rendered, nor is the queue cleared - at any time the queue can still
      be drawn by calling doRender, and the list can be cleared by calling clearRenderList.  Re-enabling the queue causes subsequent quads
      to be added as if queuing had never been disabled.

      \param setting
      true to enable queuing, or false to disable queuing (see notes above).

      \return
      Nothing
    */
    virtual void	setQueueingEnabled(bool setting)		{d_queueing = setting;}


    // create an empty texture
    virtual	Texture*	createTexture(void);

    // create a texture and load it with the specified file.
    virtual	Texture*	createTexture(const String& filename, const String& resourceGroup);

    // create a texture and set it to the specified size
    virtual	Texture*	createTexture(float size);

    // destroy the given texture
    virtual	void		destroyTexture(Texture* texture);

    // destroy all textures still active
    virtual void		destroyAllTextures(void);

    /*!
      \brief
      Return whether queuing is enabled.

      \return
      true if queuing is enabled, false if queuing is disabled.
    */
    virtual bool	isQueueingEnabled(void) const	{return d_queueing;}


    /*!
      \brief
      Return the current width of the display in pixels

      \return
      float value equal to the current width of the display in pixels.
    */
    virtual float	getWidth(void) const		{return d_display_area.getWidth();}


    /*!
      \brief
      Return the current height of the display in pixels

      \return
      float value equal to the current height of the display in pixels.
    */
    virtual float	getHeight(void) const		{return d_display_area.getHeight();}


    /*!
      \brief
      Return the size of the display in pixels

      \return
      Size object describing the dimensions of the current display.
    */
    virtual Size	getSize(void) const			{return d_display_area.getSize();}


    /*!
      \brief
      Return a Rect describing the screen

      \return
      A Rect object that describes the screen area.  Typically, the top-left values are always 0, and the size of the area described is
      equal to the screen resolution.
    */
    virtual Rect	getRect(void) const			{return d_display_area;}


    /*!
      \brief
      Return the maximum texture size available

      \return
      Size of the maximum supported texture in pixels (textures are always assumed to be square)
    */
    virtual	uint	getMaxTextureSize(void) const		{return d_maxTextureSize;}


    /*!
      \brief
      Return the horizontal display resolution dpi

      \return
      horizontal resolution of the display in dpi.
    */
    virtual	uint	getHorzScreenDPI(void) const	{return 96;}


    /*!
      \brief
      Return the vertical display resolution dpi

      \return
      vertical resolution of the display in dpi.
    */
    virtual	uint	getVertScreenDPI(void) const	{return 96;}


    /*!
      \brief
      Set the size of the display in pixels.

      If your viewport size changes, you can call this function with the new size
      in pixels to update the rendering area.

      \note
      This method will cause the EventDisplaySizeChanged event to fire if the
      display size has changed.

      \param sz
      Size object describing the size of the display.

      \return
      Nothing.
    */
    void	setDisplaySize(const Size& sz);


    /*!
      \brief
      Grabs all the loaded textures from Texture RAM and stores them in a local data buffer.
      This function invalidates all textures, and restoreTextures must be called before any
      CEGUI rendering is done for predictable results
    */
    void grabTextures(void);


    /*!
      \brief
      Restores all the loaded textures from the local data buffers previously created by 'grabTextures'
    */
    void restoreTextures(void);

    /*! 
      \brief 
      Retrieve the image codec used internaly 
    */
    ImageCodec& getImageCodec(void);
    
       
    /*! 
      \brief 
      Set the image codec to use for loading textures 
    */
    void setImageCodec(const String& codecName);

    /*!
     \brief  
     Set the image codec to use from an existing image codec.
     
     In this case the renderer does not take the ownership of the 
     image codec object. 

     \param codec a pointer to an image codec object 
     */
    void setImageCodec(ImageCodec* codec);
     
     
    /*!
      \brief 
      Set the name of the default image codec to be used 
    */
    static void setDefaultImageCodecName(const String& codecName);
    
    /*!
      \brief 
      Get the name of the default image codec 
    */
    static const String& getDefaultImageCodecName();
    

  private:
    /************************************************************************
		Implementation Constants
    ************************************************************************/
    static const int			VERTEX_PER_QUAD;							//!< number of vertices per quad
    static const int			VERTEX_PER_TRIANGLE;						//!< number of vertices for a triangle
    static const int			VERTEXBUFFER_CAPACITY;						//!< capacity of the allocated vertex buffer
    
    /*************************************************************************
		Implementation Structs & classes
    *************************************************************************/
    struct MyQuad
    {
      float tex[2];
      uint32 color;
      float vertex[3];
    };

    /*!
      \brief
      structure holding details about a quad to be drawn
    */
    struct QuadInfo
    {
      GLuint		texid;  
      Rect		position;
      float		z;
      Rect		texPosition;
      uint32		topLeftCol;
      uint32		topRightCol;
      uint32		bottomLeftCol;
      uint32		bottomRightCol;

      QuadSplitMode   splitMode;

      bool operator<(const QuadInfo& other) const
      {
	// this is intentionally reversed.
	return z > other.z;
      }

    };


    /*************************************************************************
		Implementation Methods
    *************************************************************************/
    // setup states etc
    void	initPerFrameStates(void);

    // restore states
    void  exitPerFrameStates(void);

    // render whatever is in the vertex buffer
    void	renderVBuffer(void);

    // sort quads list according to texture
    void	sortQuads(void);

    // render a quad directly to the display
    void	renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);

    // convert colour value to whatever the OpenGL system is expecting.
    uint32	colourToOGL(const colour& col) const;

    // set the module ID string
    void setModuleIdentifierString();
  
    // setup image codec 
    void setupImageCodec(const String& codecName);
    
    // cleanup image codec 
    void cleanupImageCodec();
    
    /*************************************************************************
	    Implementation Data
    *************************************************************************/
    typedef std::multiset<QuadInfo>		QuadList;
    QuadList d_quadlist;

    Rect		d_display_area;

    MyQuad		myBuff[OGLRENDERER_VBUFF_CAPACITY];

    bool		d_queueing;			//!< setting for queuing control.
    uint		d_currTexture;		//!< Currently bound texture.
    int			d_bufferPos;		//!< index into buffer where next vertex should be put.
    bool		d_sorted;			//!< true when data in quad list is sorted.

    std::list<OpenGLTexture*>	d_texturelist;		//!< List used to track textures.
    GLint       d_maxTextureSize;		//!< Holds maximum supported texture size (in pixels).
    
    ImageCodec* d_imageCodec;           //!< Holds a pointer to the image codec to use.
    DynamicModule* d_imageCodecModule; //!< Holds a pointer to the image codec module. If d_imageCodecModule is 0 we are not owner of the image codec object 
    
    static String d_defaultImageCodecName; //!< Holds the name of the default codec to use 
    
    
  };

} // End of  CEGUI namespace section

#if defined(_MSC_VER)
#	pragma warning(pop)
#endif

#endif	// end of guard _openglrenderer_h_