STAPsGLSLSupport.hpp

Go to the documentation of this file.

/******************************************************************************
STAPsGLSLSupport.hpp

Based on 3DLabs Inc. Ltd. and adapted from aGLSL.h by Martin Christen.
This class relies on using glew to initialize OpenGL.
Since Windows XP uses OpenGL 1.1, so glewInit() is needed to initialize 
the OpenGL to the highest version that the graphics card can support.

SUKITTI PUNAK   (09/09/2010)
UPDATE          (09/10/2010)
******************************************************************************/
#ifndef STAPs_GLSL_SUPPORT_HPP
#define STAPs_GLSL_SUPPORT_HPP

//-----------------------------------------------------------------------------
// Operating System Check
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
    #define TAPs_GLSL_WINDOWS
    #include <windows.h>
#elif defined(__MACOSX__)
    #define TAPs_GLSL_MACOSX
    #error "MacOSX is not supported!"
#elif defined(linux) || defined(__linux) || defined(__linux__)
    #define TAPs_GLSL_LINUX
    #error "LINUX is not supported!"
#else
    #error "This OS is not supported!"
#endif
//-----------------------------------------------------------------------------
//#include "TAPs_GL_Ext.hpp"

//#include "../Core/TAPsLib.hpp"
//#define GLEW_MX

#define GLEW_STATIC 1
#include <GL/glew.h>
#include <GL/wglew.h>
#include <GL/gl.h>
//#include <GL/glut.h>
//#include <GL/glu.h>
//#include <GL/glext.h>
//#include <GL/wglext.h>

#include "../Core/TAPsLib.hpp"
#include "../OpenGL/STAPsGLFns.hpp"
//#include "../OpenGL/TAPsOpenGLFns.hpp"

#include <iostream>
#include <fstream>
#include <vector>


#ifdef WIN32 /*[*/
#include <io.h>
#endif /*]*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>

// For wxWidgets
#ifdef TAPs_USE_WXWIDGETS
#include <wx/wx.h>
#endif

//-----------------------------------------------------------------------------
BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
class GLSLShader
{
    //----------------------------------------------------------------
    friend class GLSLProgramObject; // i.e. GLSL Program
    //----------------------------------------------------------------
public:
    //----------------------------------------------------------------
    GLSLShader ();
    ~GLSLShader ();
    int Load ( const char *fileName );  // read file returns
                                        //   0 if everything is ok,
                                        //  -1 if file not found,
                                        //  -2 if file is empty
                                        //  -3 if no memory
    // Load shader from char array, make sure shader is 0 terminated!
    void LoadFromMemory ( const char *shader );
    bool Compile ();            // compile shader
    char * GetCompilerLog ();   // get compiler log messages
    GLint GetAttribLoc ( char * cpAttribName ); // get localtion of the attribute

    void SetName ( std::string const & name )   { m_name = name; }
    std::string const & GetName ()  { return m_name; }
    //----------------------------------------------------------------
protected:
    //----------------------------------------------------------------
    // Data Members
    int         m_iShaderType;      
    GLuint      m_uiShaderObject;   
    GLchar *    m_cpShaderSource;   
    bool        m_bCompileStatus;   
    GLchar *    m_cpCompilerLog;    
    bool        m_bMemAlloc;        
    std::string m_name;             
    //----------------------------------------------------------------
};
//=============================================================================
class GLSLVertexShader : public GLSLShader
{
public:
    GLSLVertexShader ();
    ~GLSLVertexShader ();
};
//=============================================================================
class GLSLGeometryShader : public GLSLShader
{
public:
    GLSLGeometryShader ();
    ~GLSLGeometryShader ();
};
//=============================================================================
class GLSLFragmentShader : public GLSLShader
{
public:
    GLSLFragmentShader ();
    ~GLSLFragmentShader ();
};
//=============================================================================
// GLSL Program
class GLSLProgramObject
{
public:
    //----------------------------------------------------------------
    GLSLProgramObject ();
    ~GLSLProgramObject ();
    //----------------------------------------------------------------
    // Add a vertex or fragment shader
    void AddShader ( GLSLShader * glslShader );
    //----------------------------------------------------------------
    bool Link ();               // link all shaders
    char * GetLinkerLog ();     // get linker messages
    //----------------------------------------------------------------
    // Begin this shader.  OpenGL calls will go through shader
    void BeginGLSL ();
    // Stop using this shader. OpenGL calls will go through regular pipeline.
    void EndGLSL ();
    //----------------------------------------------------------------
    bool IsGLSLEnabled ();  // returns true if GLSL is enabled
    //----------------------------------------------------------------
    GLuint GetProgramObject () {
        return m_uiProgramObject;
    }
    //----------------------------------------------------------------
    GLuint const GetProgramObject () const {
        return m_uiProgramObject;
    }
    //----------------------------------------------------------------
    // To set (uniform) Textures to GLSL Shader
    //   only glUniform1i and glUniform1iv can be used to load texture(s)
    //---------------------------------------------------------------
    // Set Uniform Variables to GLSL Shader
    //---------------------------------------------------------------
    // Float
    bool SetUniform1f   ( char * var, GLfloat x );
    bool SetUniform2f   ( char * var, GLfloat x, GLfloat y );
    bool SetUniform3f   ( char * var, GLfloat x, GLfloat y, GLfloat z );
    bool SetUniform4f   ( char * var, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
    //-----------------------
    // Float Vector
    bool SetUniform1fv  ( char * var, GLsizei count, GLfloat * val );
    bool SetUniform2fv  ( char * var, GLsizei count, GLfloat * val );
    bool SetUniform3fv  ( char * var, GLsizei count, GLfloat * val );
    bool SetUniform4fv  ( char * var, GLsizei count, GLfloat * val );
    //-----------------------
    // Integer
    bool SetUniform1i   ( char * var, GLint x );
    bool SetUniform2i   ( char * var, GLint x, GLint y );
    bool SetUniform3i   ( char * var, GLint x, GLint y, GLint z );
    bool SetUniform4i   ( char * var, GLint x, GLint y, GLint z, GLint w );
    //-----------------------
    // Integer Vector
    bool SetUniform1iv  ( char * var, GLsizei count, GLint * val );
    bool SetUniform2iv  ( char * var, GLsizei count, GLint * val );
    bool SetUniform3iv  ( char * var, GLsizei count, GLint * val );
    bool SetUniform4iv  ( char * var, GLsizei count, GLint * val );
    //-----------------------
    // Unsigned Integer
    bool SetUniform1ui  ( char * var, GLuint x );
    bool SetUniform2ui  ( char * var, GLuint x, GLuint y );
    bool SetUniform3ui  ( char * var, GLuint x, GLuint y, GLuint z );
    bool SetUniform4ui  ( char * var, GLuint x, GLuint y, GLuint z, GLuint w );
    //-----------------------
    // Unsigned Integer Vector
//  bool SetUniform1uiv ( char * var, GLsizei count, GLuint * val );
//  bool SetUniform2uiv ( char * var, GLsizei count, GLuint * val );
//  bool SetUniform3uiv ( char * var, GLsizei count, GLuint * val );
//  bool SetUniform4uiv ( char * var, GLsizei count, GLuint * val );
    //-----------------------
    bool SetUniformMatrix2fv    ( char * var, GLsizei count, GLboolean transpose, GLfloat * val );
    bool SetUniformMatrix3fv    ( char * var, GLsizei count, GLboolean transpose, GLfloat * val );
    bool SetUniformMatrix4fv    ( char * var, GLsizei count, GLboolean transpose, GLfloat * val );
    //----------------------------------------------------------------
    // Get Uniform Variables from GLSL Shader
    void GetUniformfv   ( char * var, GLfloat * val );  // float
    void GetUniformiv   ( char * var, GLint *   val );  // int
    void GetUniformuiv  ( char * var, GLuint *  val );  // unsigned int
    //----------------------------------------------------------------
    // Set Vertex Attributes to GLSL Shader
    bool SetVertexAttrib1f ( GLuint index, GLfloat x );
    bool SetVertexAttrib2f ( GLuint index, GLfloat x, GLfloat y );
    bool SetVertexAttrib3f ( GLuint index, GLfloat x, GLfloat y, GLfloat z );
    bool SetVertexAttrib4f ( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
    //----------------------------------------------------------------
    void MemageMemory () { m_bManageMemory = true; }
    //----------------------------------------------------------------
    // Turn On/Off All Shaders
    static void UseShader ( bool b ) { m_stcbShaderActive = b; }

    void SetName ( std::string const & name )   { m_name = name; }
    std::string const & GetName ()  { return m_name; }
    //----------------------------------------------------------------
private:
    //----------------------------------------------------------------
    // Member Functions
    GLint   GetUniLoc( const GLchar *name );    // get location of the uniform variable
    //----------------------------------------------------------------
    // Data Members
    GLuint      m_uiProgramObject;  
    bool        m_bLinkStatus;      
    GLchar *    m_cpLinkerLog;      
    std::vector< GLSLShader * > m_vShaderList;  // list of all shaders
    bool        m_bManageMemory;    
    static bool m_stcbShaderActive; 
    std::string m_name;             
    //----------------------------------------------------------------
};
//=============================================================================
class GLSLShaderManager
{
public:
    GLSLShaderManager ();
    ~GLSLShaderManager ();
    //---------------------------------------------------------------
    bool CreateGLSLProgramObject ( GLSLProgramObject * (&progObj) );
    bool AttachShaderFromFile ( GLSLProgramObject * progObj, char const * shaderFile, GLuint shaderType );
    inline bool AttachShaderFromFile ( GLSLProgramObject * progObj, std::string & shaderFile, GLuint shaderType )
    { return AttachShaderFromFile ( progObj, shaderFile.c_str(), shaderType ); }
    bool Link ( GLSLProgramObject * progObj );
    //---------------------------------------------------------------
    // Load vertex/geometry/fragment shader(s) from file(s)
    GLSLProgramObject * LoadVertexGeometryAndFragmentShadersFromFile ( 
        char * vertFile, char * geomFile, char * fragFile );
    GLSLProgramObject * LoadVertexAndFragmentShadersFromFile ( 
        char * vertFile, char * fragFile )
    {   return LoadFromFile( vertFile, fragFile );  }
    //GLSLProgramObject * LoadVertexAndGeometryFragmentShadersFromFile ( 
    //  char * vertFile, char * geomFile );
    //GLSLProgramObject * LoadGeometryAndFragmentShadersFromFile ( 
    //  char * geomFile, char * fragFile );
    GLSLProgramObject * LoadFromFile ( char * vertFile, char * fragFile );
    GLSLProgramObject * LoadOnlyAVertexShaderFromFile ( char * vertFile );
    GLSLProgramObject * LoadOnlyAGeometryShaderFromFile ( char * geomFile );
    GLSLProgramObject * LoadOnlyAFragmentShaderFromFile ( char * fragFile );
    //---------------------------------------------------------------
    // Load vertex/fragment shader from memory
    GLSLProgramObject * LoadFromMemory ( const char * vertMem, const char * fragMem );
    //---------------------------------------------------------------
    // Delete a program object
    bool Delete ( GLSLProgramObject * obj );
    //----------------------------------------------------------------
    std::vector< GLSLProgramObject * > & GetProgramObjectList () {
        return m_vProgramObjectList;
    }
    //----------------------------------------------------------------
    std::vector< GLSLProgramObject * > const & GetProgramObjectList () const {
        return m_vProgramObjectList;
    }
    //----------------------------------------------------------------
protected:
    bool LoadVertexShaderFromFile   ( GLSLVertexShader *   vertShader, const char * vertFile );
    bool LoadGeometryShaderFromFile ( GLSLGeometryShader * geomShader, const char * geomFile );
    bool LoadFragmentShaderFromFile ( GLSLFragmentShader * fragShader, const char * fragFile );
    bool CompileVertexShaderFromFile    ( GLSLVertexShader *   vertShader, const char * vertFile );
    bool CompileGeometryShaderFromFile  ( GLSLGeometryShader * geomShader, const char * vertFile );
    bool CompileFragmentShaderFromFile  ( GLSLFragmentShader * fragShader, const char * vertFile );
    //----------------------------------------------------------------
private:
    std::vector< GLSLProgramObject * >  m_vProgramObjectList;
    //===============================================================
    //---------------------------------------------------------------
    // For Attributes / Uniform Variables
    //===========================================
    // Uniform Variables
    //-------------------------------------------
    // Scalars
    std::vector< float >            m_f1Uniform;
    std::vector< int >              m_i1Uniform;
    std::vector< bool >             m_b1Uniform;
    //-------------------------------------------
    // Vectors
    std::vector< Vector2<float> >   m_f2Uniform;
    std::vector< Vector2<int> >     m_i2Uniform;
    std::vector< Vector2<bool> >    m_b2Uniform;
    std::vector< Vector3<float> >   m_f3Uniform;
    std::vector< Vector3<int> >     m_i3Uniform;
    std::vector< Vector3<bool> >    m_b3Uniform;
    std::vector< Vector4<float> >   m_f4Uniform;
    std::vector< Vector4<int> >     m_i4Uniform;
    std::vector< Vector4<bool> >    m_b4Uniform;
    //-------------------------------------------
    // Matrices
    std::vector< ColMatrix2x2<float> >  m_m2x2Uniform;
    std::vector< ColMatrix3x3<float> >  m_m3x3Uniform;
    std::vector< ColMatrix4x4<float> >  m_m4x4Uniform;
    //-------------------------------------------
    // Samplers
    // --------
    // sampler1D        Access a 1D texture
    // sampler2D        Access a 2D texture
    // sampler3D        Access a 3D texture
    // samplerCube      Access a cube-map texture
    // sampler1DShadow  Access a 1D depth texture with comparison
    // sampler2DShadow  Access a 2D depth texture with comparison
    //-------------------------------------------
    //===========================================
    // Attributes
    //-------------------------------------------
    // Scalars
    std::vector< short >            m_s1VertexAttrib;
    std::vector< float >            m_f1VertexAttrib;
    std::vector< double >           m_d1VertexAttrib;
    //-------------------------------------------
    // 2D Vectors
    std::vector< Vector2<short> >   m_s2VertexAttrib;
    std::vector< Vector2<float> >   m_f2VertexAttrib;
    std::vector< Vector2<double> >  m_d2VertexAttrib;
    // 3D Vectors
    std::vector< Vector3<short> >   m_s3VertexAttrib;
    std::vector< Vector3<float> >   m_f3VertexAttrib;
    std::vector< Vector3<double> >  m_d3VertexAttrib;
    // 4D Vectors
    std::vector< Vector4<short> >   m_s4VertexAttrib;
    std::vector< Vector4<float> >   m_f4VertexAttrib;
    std::vector< Vector4<double> >  m_d4VertexAttrib;
    std::vector< Vector4<char> >    m_b4VertexAttrib;
    std::vector< Vector4<int> >     m_i4VertexAttrib;
    std::vector< Vector4<unsigned char> >   m_ub4VertexAttrib;
    std::vector< Vector4<unsigned short> >  m_us4VertexAttrib;
    std::vector< Vector4<unsigned int> >    m_ui4VertexAttrib;
    //---------------------------------------------------------------
    //===============================================================
    //-------------------------------------------------------------------------
};  // End Class GLSLShaderManager
//=============================================================================
// * \class GLSLSupport STAPsGLSLSupport.hpp "OpenGL/STAPsGLSLSupport.hpp"
// * \brief To simplify the process of loading/compiling/linking shaders, this
// */
//class GLSLSupport
//{
//public:
//  // Data Members
//  GLuint VAO;             //!< the vertex array object
//  GLunit VBO_Positions;   //!< the vertex buffer object for positions
//  GLunit VBO_Indices;     //!< the vertex buffer object for indices
//};
//=============================================================================
// Classless functions to initialize OpenGL Extensions and check for GLSL and OpenGL
bool GFnInitGLSL    ();
bool GFnCheckGLSL   ();
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
#if !defined( TAPs_USE_EXPORT )
    #include "STAPsGLSLSupport.cpp"
#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8