//------------------------------------------------------------------------------
// File : RenderTexture.h
//------------------------------------------------------------------------------
// Copyright (c) 2002-2004 Mark J. Harris
//---------------------------------------------------------------------------
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any
// damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any
// purpose, including commercial applications, and to alter it and
// redistribute it freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you
//    must not claim that you wrote the original software. If you use
//    this software in a product, an acknowledgment in the product
//    documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and
//    must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
// -----------------------------------------------------------------------------
// Credits:
// Original RenderTexture code: Mark J. Harris
// Original Render-to-depth-texture support: Thorsten Scheuermann
// Linux Copy-to-texture: Eric Werness
// Various Bug Fixes: Daniel (Redge) Sperl 
//                    Bill Baxter
//                    Florian Kirsch
//                    Andrew Wood
// Deprecated Interface Removed: Florian Kirsch
//
// -----------------------------------------------------------------------------
/**
* @file RenderTexture.h
* 
* Interface definition for class RenderTexture.  A multi-format render to 
* texture wrapper.
*/
#ifndef __RENDERTEXTURE2_HPP__
#define __RENDERTEXTURE2_HPP__

#ifndef __APPLE__

#include <GL/glew.h>
#ifdef _WIN32
#include <GL/wglew.h>
#else
#include <GL/glxew.h>
#endif

#include <string>
#include <vector>

/* The pixel format for the pbuffer is controlled by the mode string passed
* into the PBuffer constructor. This string can have the following attributes:
*
* To specify the pixel format, use the following syntax.
*   <channels>=<bits>
* <channels> must match one of the following.
*
* r			   - r pixel format (for float buffer).
* rg		   - rg pixel format (for float buffer).
* rgb          - rgb pixel format. 8 bit or 16/32 bit in float buffer mode
* rgba         - same as "rgb alpha" string
*
* <bits> can either be a scalar--meaning the same bit depth for each 
* channel-- or a 2-, 3-, 4-component vector matching the specified number of 
* channels. Vector components should be comma separated. An optional 'f' 
* suffix on the bit depth specifies float components.  In this case <bits> 
* must be either "32f" or "16f".  If <bits> is empty, the default 8 bits per
* channel will be used.
*   r=32f
*   rg=16f
*   rgb=8
*   rgb=5,6,5
*
* The following other attributes are supported.
*
* depth=n      - must have n-bit depth buffer, omit n for default (24 bits)
* stencil=n    - must have n-bit stencil buffer, omit n for default (8 bits)
* samples=n    - must support n-sample antialiasing (n can be 2 or 4)
* aux=n        - must have n AUX buffers
* doublebuffer - must support double buffered rendering
* singlebuffer - do not support double buffered rendering
* 
* tex2D
* texRECT
* texCUBE  - must support binding pbuffer as texture to specified target
*          - binding the depth buffer is also supported by specifying
* depthTex2D
* depthTexRECT
* depthTexCUBE
*          - Both depth and color texture binding, may be specified, but
*            the targets must match!
*            For example: "tex2D depthTex2D" or "texRECT depthTexRECT"
*
* rtt
* ctt      - These mutually exclusive options specify the update method used
*            for render textures that support texture binding. "rtt"
*            indicates that render to texture will be used to update the 
*            texture. "ctt" indicates that copy to texture will be used 
*            (i.e. glCopyTexSubImage2D()). "rtt" is the default if neither is 
*            specified, and one of the "tex*" options above is. 
* 
*
*---------------------------------------------------------------------------
*
* USAGE NOTES:
*
* * Texture Parameters:
*   The default texture wrap mode is GL_CLAMP_TO_EDGE for all textures, and
*   the default texture filtering modes (min and mag) are GL_NEAREST. 
*   To change these parameters, simply bind the RenderTexture (using the
*   Bind() method), and set them the way you would for any GL texture object.
*   The same goes for depth textures.
*
* * Enabling Mipmapping:
*   This is similar to the texture parameters above.  When "rtt" is specified
*   in the mode string, "mipmap" must also be specified in order to enable
*   a mipmapped pbuffer.  Then, the mipmaps must be created by enabling the
*   GL_SGIS_GENERATE_MIPMAP texture parameter in the same way as above, and
*   the min filter mode must be set to a mipmap filter mode, as with any
*   mipmapped texture object.
*
* * Enabling Anisotropic Filtering  
*   As with the texture parameters above, except as in the following code:
*   glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, max);
*   glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, <value < max>);
*/
class RenderTexture
{
public: // enums
    enum UpdateMode
    {
        RT_RENDER_TO_TEXTURE,
        RT_COPY_TO_TEXTURE
    };
    
public: // interface
    // ctor / dtor
    RenderTexture(const char *strMode="rgb tex2D");
    ~RenderTexture();
    
    //! Call this once before use.  Set bShare to true to share lists, textures, 
    //! and program objects between the render texture context and the 
    //! current active GL context.
    bool Initialize(int width, int height, 
                    bool shareObjects=true, 
                    bool copyContext=false);

    // !Change the render texture format.
    bool Reset(const char* strMode,...);
    // !Change the size of the render texture.
    bool Resize(int width, int height);
    
    // !Begin drawing to the texture. (i.e. use as "output" texture)
    bool BeginCapture();
    // !Ends drawing to 'current', begins drawing to this RenderTexture
    bool BeginCapture(RenderTexture* current);
    // !End drawing to the texture.
    bool EndCapture();
    
    // !Bind the texture to the active texture unit for use as an "input" texture
    void Bind() const;

    // !Bind the depth texture to the active texture unit for use as an "input" texture
    void BindDepth() const; 

    // !Associate the RTT texture with 'iBuffer' (default is WGL_FRONT_LEFT_ARB) 
    bool BindBuffer( int iBuffer );

    //! Enables the texture target appropriate for this render texture.
    void EnableTextureTarget() const 
    { if (_bInitialized) glEnable(_iTextureTarget); }
    //! Disables the texture target appropriate for this render texture.
    void DisableTextureTarget() const 
    { if (_bInitialized) glDisable(_iTextureTarget); }
    
    //! Returns the texture ID.  Useful in Cg applications.
    unsigned int GetTextureID() const  { return _iTextureID; }
    //! Returns the depth texture ID.  Useful in Cg applications.
    unsigned int GetDepthTextureID() const { return _iDepthTextureID; }
    //! Returns the texture target this texture is bound to.
    unsigned int GetTextureTarget() const { return _iTextureTarget; }
    //! Conversion operator allows RenderTexture to be passed to GL calls
    operator unsigned int()const{return _iTextureID;}     
    
    //! Returns the width of the offscreen buffer.
    int GetWidth() const            { return _iWidth;  } 
    //! Returns the width of the offscreen buffer.
    int GetHeight() const           { return _iHeight; }
    //! Returns the maximum S texture coordinate.
    int GetMaxS() const      { return IsRectangleTexture() ? _iWidth : 1; }                  
    //! Returns the maximum T texture coordinate.
    int GetMaxT() const      { return IsRectangleTexture() ? _iHeight : 1; }                  
    
    //! Returns the number of red bits allocated.
    int GetRedBits() const          { return _iNumColorBits[0]; }
    //! Returns the number of green bits allocated.
    int GetGreenBits() const        { return _iNumColorBits[1]; }
    //! Returns the number of blue bits allocated.
    int GetBlueBits() const         { return _iNumColorBits[2]; }
    //! Returns the number of alpha bits allocated.
    int GetAlphaBits() const        { return _iNumColorBits[3]; }

    //! Returns the number of depth bits allocated.
    int GetDepthBits() const        { return _iNumDepthBits; }
    //! Returns the number of stencil bits allocated.
    int GetStencilBits() const      { return _iNumStencilBits; }
    
    //! True if this RenderTexture has been properly initialized.
    bool IsInitialized() const      { return _bInitialized; }
    //! True if this is a texture and not just an offscreen buffer.
    bool IsTexture() const          { return _bIsTexture; }
    //! True if this is a depth texture and not just an offscreen buffer.
    bool IsDepthTexture() const     { return _bIsDepthTexture; }
    //! True if this is a floating point buffer / texture.
    bool IsFloatTexture() const     { return _bFloat; }
    //! True if this is a double-buffered pbuffer
    bool IsDoubleBuffered() const   { return _bDoubleBuffered; }
    //! True if this texture has non-power-of-two dimensions.
    bool IsRectangleTexture() const { return _bRectangle; }
    //! True if this texture has non-power-of-two dimensions.
    //! True if this pbuffer has a depth buffer.
    bool HasDepth() const           { return (_iNumDepthBits > 0); }
    //! True if this pbuffer has a stencil buffer.
    bool HasStencil() const         { return (_iNumStencilBits > 0); }
    //! True if this texture has mipmaps.
    bool IsMipmapped() const        { return _bMipmap; }

    /**
    * @fn IsPowerOfTwo(int n)
    * @brief Returns true if /param n is an integer power of 2.
    * 
    * Taken from Steve Baker's Cute Code Collection. 
    * http://www.sjbaker.org/steve/software/cute_code.html
    */ 
    static bool IsPowerOfTwo(int n) { return ((n&(n-1))==0); }


protected: // methods
    bool         _Invalidate();

    typedef std::pair<std::string, std::string> KeyVal;

    void _ParseModeString(const char *modeString, 
                          std::vector<int> &pixelFormatAttribs, 
                          std::vector<int> &pbufferAttribs);

    std::vector<int> _ParseBitVector(std::string bitVector);
    KeyVal _GetKeyValuePair(std::string token);


    bool _VerifyExtensions();
    bool _InitializeTextures();
    
    void _MaybeCopyBuffer();
    bool _ReleaseBoundBuffers();
    bool _MakeCurrent();
    bool _BindDepthBuffer( ) const;

protected: // data
    int          _iWidth;     // width of the pbuffer
    int          _iHeight;    // height of the pbuffer
    
    bool         _bIsTexture;
    bool         _bIsDepthTexture;
    bool         _bHasARBDepthTexture; // [Redge]
    
    UpdateMode   _eUpdateMode;
        
    bool         _bInitialized;
    
    unsigned int _iNumAuxBuffers;
    bool         _bIsBufferBound;
    int          _iCurrentBoundBuffer;
    
    unsigned int _iNumComponents;
    unsigned int _iNumColorBits[4];
    unsigned int _iNumDepthBits;
    unsigned int _iNumStencilBits;

    
    bool         _bFloat;
    bool         _bDoubleBuffered;
    bool         _bPowerOf2;
    bool         _bRectangle;
    bool         _bMipmap;
    
    bool         _bShareObjects;
    bool         _bCopyContext;
    
#ifdef _WIN32
    HDC          _hDC;        // Handle to a device context.
    HGLRC        _hGLContext; // Handle to a GL context.
    HPBUFFERARB  _hPBuffer;   // Handle to a pbuffer.
    
    HDC          _hPreviousDC;
    HGLRC        _hPreviousContext;
#else
    Display     *_pDisplay;
    GLXContext   _hGLContext;
    GLXPbuffer   _hPBuffer;
    
    GLXDrawable  _hPreviousDrawable;
    GLXContext   _hPreviousContext;
#endif
    
    // Texture stuff
    GLenum       _iTextureTarget;
    unsigned int _iTextureID;
    unsigned int _iDepthTextureID;
    
    unsigned short* _pPoorDepthTexture; // [Redge]

    std::vector<int> _pixelFormatAttribs;
    std::vector<int> _pbufferAttribs;

private:
    // Using these could lead to some odd behavior
    RenderTexture(const RenderTexture&);
    RenderTexture& operator=(const RenderTexture&);
};

#endif // __APPLE__

#endif //__RENDERTEXTURE2_HPP__
