TAPsGLARBVertexBufferObject.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsGLARBVertexBufferObject.hpp

Based on 3DLabs Inc. Ltd. and aGLSL.h by Martin Christen

SUKITTI PUNAK   (06/08/2005)
UPDATE          (09/10/2010)
******************************************************************************/
#ifndef TAPs_GLARBVERTEXBUFFEROBJECT_HPP
#define TAPs_GLARBVERTEXBUFFEROBJECT_HPP

//-----------------------------------------------------------------------------
#ifndef TAPs_USE_GLSL
    #define TAPs_USE_GLSL
#endif
//-----------------------------------------------------------------------------
// 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_STATIC 1
#include <GL/glew.h>
#include <GL/wglew.h>
#include <GL/gl.h>
#include <GL/glext.h>
//#include <GL/glut.h>
//#include <GL/glu.h>
//#include <GL/wglext.h>

#include "../Core/TAPsLib.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
//=============================================================================
//-----------------------------------------------------------------------------
// Useful Macros
/*
#ifdef TAPs_GLSL_WINDOWS
#define MacrosLoadExtension( fnType, fnName ) ( ( fnName = (fnType) wglGetProcAddress( #fnName ) ) == NULL )
#endif
#ifdef TAPs_GLSL_LINUX
#define MacrosLoadExtension( fnType, fnName ) ( ( fnName = (fnType) glXGetProcAddress( #fnName ) ) == NULL )
#endif
bool GFnTestExtension( const char * extName );
*/
//=============================================================================
class GLSLShader
{
    //----------------------------------------------------------------
    friend class GLSLProgramObject; // i.e. GLSL Program
    //----------------------------------------------------------------
public:
    //----------------------------------------------------------------
    GLSLShader ();
    ~GLSLShader ();
    int Load ( 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
    //----------------------------------------------------------------
protected:
    //----------------------------------------------------------------
    // Data Members
    int         m_iShaderType;      // 1 = Vertex Shader; 2 = Fragment Shader; else NONE
    GLuint      m_uiShaderObject;   // shader object
    GLchar *    m_cpShaderSource;   // ASCII source code
    bool        m_bCompileStatus;   // true if shader is compiled
    GLchar *    m_cpCompilerLog;    // compiler log message
    bool        m_bMemAlloc;        // true if shader allocated memory
    //----------------------------------------------------------------
};
//=============================================================================
class GLSLVertexShader : public GLSLShader
{
public:
    GLSLVertexShader ();
    ~GLSLVertexShader ();
};
//=============================================================================
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
    //----------------------------------------------------------------
    // Set Uniform Variables to GLSL Shader
    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 );
    //-----------------------
    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 );
    //-----------------------
    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 );
    //-----------------------
    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 );
    //-----------------------
    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 );
    void GetUniformiv   ( char * var, GLint * val );
    //----------------------------------------------------------------
    // 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; }
    //----------------------------------------------------------------
private:
    //----------------------------------------------------------------
    // Member Functions
    GLint   GetUniLoc( const GLchar *name );    // get location of the uniform variable
    //----------------------------------------------------------------
    // Data Members
    GLuint      m_uiProgramObject;  // shader object
    bool        m_bLinkStatus;      // true if shader is linked
    GLchar *    m_cpLinkerLog;      // linker log message
    std::vector< GLSLShader * > m_vShaderList;  // list of all shaders
    bool        m_bManageMemory;    // true if shader manages memory
    static bool m_stcbShaderActive; // true if shader is inactive
    //----------------------------------------------------------------
};
//=============================================================================
// To simplify the process loading/compiling/linking shaders, this
// high level interface to setup a vertex/fragment shader has been created.
class GLSLShaderManager
{
public:
    GLSLShaderManager ();
    ~GLSLShaderManager ();
    //---------------------------------------------------------------
    // Load vertex/fragment shader from file
    GLSLProgramObject * LoadFromFile ( char * vertFile, char * fragFile );
    //---------------------------------------------------------------
    // Load vertex/fragment shader from memory
    GLSLProgramObject * LoadFromMemory ( const char * vertMem, const char * fragMem );
    //---------------------------------------------------------------
    // Delete a program object
    bool Delete ( GLSLProgramObject * obj );
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
//=============================================================================
// Classless functions to initialize OpenGL Extensions and check for GLSL and 
// OpenGL Version 2
bool GFnInitGLSL    ();
bool GFnCheckGLSL   ();
bool GFnCheckGL2    ();
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
#if !defined( TAPs_USE_EXPORT )
    #include "TAPsGLSLFns.cpp"
#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8