A interface layer to mape old ARB API to newer opengl function names

GLShaderFunctionMapping.cpp

#ifndef ANDROID_NDK
#include <GL/glew.h>
#endif

#include "Logging.h"
#include "GLIncludes.h"
#include "GLHelpers.h"


//*****************************************************************************
void shaderSource(GLuint shader, GLsizei count, const GLchar* *string, 
    const GLint *length)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    glShaderSourceARB(shader, count, string,  length);
  }
  else
#endif
  {
    glShaderSource(shader, count, string,  length);
  }

}

//*****************************************************************************
void compileShader (GLuint shader)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    glCompileShaderARB(shader);
  }
  else
#endif
  {
    glCompileShader(shader);
  }

}

//*****************************************************************************
void getShaderiv (GLuint id, GLenum pname, GLint *params)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    if(pname == GL_COMPILE_STATUS)
    {
      pname = GL_OBJECT_COMPILE_STATUS_ARB;
    }
    else if(pname == GL_INFO_LOG_LENGTH)
    {
      pname = GL_OBJECT_INFO_LOG_LENGTH_ARB;
    }
    glGetObjectParameterivARB(id, pname, params);
  }
  else
#endif
  {

    glGetShaderiv(id, pname, params);
  }

}

//*****************************************************************************
void getShaderInfoLog (GLuint id, GLsizei max_length, GLsizei *length, 
    GLchar *infoLog)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    glGetInfoLogARB(id, max_length, length, infoLog);
  }
  else
#endif
  {

    glGetShaderInfoLog(id, max_length, length, infoLog);
  }
}

#ifdef PC_BUILD
//*****************************************************************************
/**
 *  Convert target of a buffer command
 */
void convertTarget(GLenum& target)
{

  if(target == GL_ARRAY_BUFFER)
  {
    target = GL_ARRAY_BUFFER_ARB;
  }
  else if(target == GL_ELEMENT_ARRAY_BUFFER)
  {
    target = GL_ELEMENT_ARRAY_BUFFER_ARB;
  }
}
#endif

//*****************************************************************************
void bindBuffer (GLenum target, GLuint buffer)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {

    convertTarget(target);
    return glBindBufferARB(target, buffer);
  }
  else
#endif
  {
    return glBindBuffer(target, buffer);
  }

}

//*****************************************************************************
void bufferData (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {

    convertTarget(target);
    return glBufferDataARB(target, size, data, usage);
  }
  else
#endif
  {
    return glBufferData(target, size, data, usage);
  }

}

//*****************************************************************************
void genBuffers (GLsizei n, GLuint *buffers)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    return glGenBuffersARB(n, buffers);
  }
  else
#endif
  {
    return glGenBuffers(n, buffers);
  }

}

//*****************************************************************************
void deleteBuffers (GLsizei n, const GLuint *buffers)
{

  LOGD("deleteBuffers (VBO)...\n");
#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    return glDeleteBuffersARB (n, buffers);
  }
  else
#endif
  {
    return glDeleteBuffers (n, buffers);
  }

}

//*****************************************************************************
void detachShader (GLuint program, GLuint shader)
{

  LOGD("detachShader(%u,%u)...\n", program, shader);
#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {

    return glDetachObjectARB(program, shader);
  }
  else
#endif
  {
    return glDetachShader(program, shader);
  }


}

//*****************************************************************************
void deleteProgram (GLuint id)
{

  LOGD("deleteProgram(%d)...\n", id);
#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {

    return glDeleteObjectARB(id);
  }
  else
#endif
  {
    return glDeleteProgram(id);
  }

}

//*****************************************************************************
void deleteShader (GLuint id)
{

  LOGD("deleteShader(%d)...\n", id);
#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {

    return glDeleteObjectARB(id);
  }
  else
#endif
  {
    return glDeleteShader(id);
  }

}

//*****************************************************************************
GLuint createShader (GLenum type)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    return glCreateShaderObjectARB(type);
  }
  else
#endif
  {
    return glCreateShader(type);
  }

}

//*****************************************************************************
void useProgram (GLuint program)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glUseProgramObjectARB(program);
    }
    else
#endif
    {
      glUseProgram(program);
    }

}

//*****************************************************************************
void uniform2fv(GLint location, GLsizei count, const GLfloat* v0)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glUniform2fvARB(location, 1, v0);
    }
    else
#endif
    {
      glUniform2fv(location, 1, v0);
    }

}


//*****************************************************************************
void uniform1i (GLint location, GLint v0)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glUniform1iARB(location,v0);
    }
    else
#endif
    {
      glUniform1i(location, v0);
    }

}

//*****************************************************************************
void vertexAttribPointer (GLuint index, GLint size, GLenum type, 
    GLboolean normalized, GLsizei stride, const GLvoid *pointer)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {

      glVertexAttribPointerARB(index, size, type, normalized, stride, pointer);
    }
    else
#endif
    {
      glVertexAttribPointer(index, size, type, normalized, stride, pointer);
    }

}

//*****************************************************************************
void disableVertexAttribArray (GLuint index)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {

      glDisableVertexAttribArrayARB (index);
    }
    else
#endif
    {
      glDisableVertexAttribArray(index);
    }

}

//*****************************************************************************
void enable( GLenum cap )
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {

      if(cap == GL_PROGRAM_POINT_SIZE)
      {
        cap = GL_PROGRAM_POINT_SIZE_ARB;
      }
      else if(cap == GL_POINT_SPRITE)
      {
        cap = GL_POINT_SPRITE_ARB;
      }
      glEnable (cap);
    }
    else
#endif
    {
      glEnable(cap);
    }

}

//*****************************************************************************
void enableVertexAttribArray(GLuint index)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {

      glEnableVertexAttribArrayARB(index);
    }
    else
#endif
    {
      glEnableVertexAttribArray(index);
    }

}

//*****************************************************************************
GLint getAttribLocation (GLuint program, const GLchar *name)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    return glGetAttribLocationARB(program, name);
  }
  else
#endif
  {

    return glGetAttribLocation(program, name);
  }

}

//*****************************************************************************
GLint getUniformLocation (GLuint program, const GLchar *name)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    return glGetUniformLocationARB(program, name);
  }
  else
#endif
  {

    return glGetUniformLocation(program, name);
  }

}

//*****************************************************************************
GLuint createProgram (void)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    return glCreateProgramObjectARB();
  }
  else
#endif
  {
    return  glCreateProgram();
  }

}

//*****************************************************************************
void uniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose,
    const GLfloat *value)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    glUniformMatrix4fvARB(location, count, transpose, value);
  }
  else
#endif
  {
    glUniformMatrix4fv(location, count, transpose, value);
  }

}

//*****************************************************************************
void uniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose,
    const GLfloat *value)
{

#ifdef PC_BUILD
  if(!GLEW_VERSION_2_1)
  {
    glUniformMatrix2fvARB(location, count, transpose, value);
  }
  else
#endif
  {
    glUniformMatrix2fv(location, count, transpose, value);
  }

}


//*****************************************************************************
void uniform1f (GLint location, GLfloat v0)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glUniform1fARB(location, v0);
    }
    else
#endif
    {
      glUniform1f(location, v0);
    }

}

//*****************************************************************************
void attachShader (GLuint program, GLuint shader)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glAttachObjectARB(program, shader);
    }
    else
#endif
    {
      glAttachShader(program, shader);
    }

}

//*****************************************************************************
void linkProgram (GLuint program)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glLinkProgramARB(program);
    }
    else
#endif
    {
      glLinkProgram(program);
    }

}

//*****************************************************************************
void getProgramiv(GLuint program, GLenum pname, GLint* params)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {

      if(pname == GL_LINK_STATUS)
      {

        pname = GL_OBJECT_LINK_STATUS_ARB;
      }
      else if(pname == GL_INFO_LOG_LENGTH)
      {

        pname = GL_OBJECT_INFO_LOG_LENGTH_ARB;
      }

      glGetObjectParameterivARB(program, pname, params);
    }
    else
#endif
    {
      glGetProgramiv(program, pname, params);
    }

}

//*****************************************************************************
void getProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length,
    GLchar *infoLog)
{

#ifdef PC_BUILD
    if(!GLEW_VERSION_2_1)
    {
      glGetInfoLogARB(program, bufSize, length, infoLog);
    }
    else
#endif
    {
      glGetProgramInfoLog(program, bufSize, length, infoLog);
    }

}

GLShaderFunctionMapping.h

#ifndef GLSHADERFUNCTIONMAPPING_H
#define GLSHADERFUNCTIONMAPPING_H 

#include "GLHelpers.h"

#ifdef PC_BUILD
void convertTarget(GLenum& target);
#endif

void deleteProgram (GLuint id);
void detachShader (GLuint program, GLuint shader);
void deleteShader (GLuint id);
void disableVertexAttribArray (GLuint index);
void enable( GLenum cap );
void bufferData (GLenum target, GLsizeiptr size, const GLvoid *data, 
    GLenum usage);
void bindBuffer (GLenum target, GLuint buffer);
void genBuffers (GLsizei n, GLuint *buffers);
void deleteBuffers (GLsizei n, const GLuint *buffers);
void shaderSource(GLuint shader, GLsizei count, const GLchar* *string, const
    GLint *length);
void compileShader (GLuint shader);
void getShaderiv (GLuint shader, GLenum pname, GLint *params);
void getShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, 
    GLchar *infoLog);
GLuint createShader (GLenum type);
void useProgram (GLuint program);
void uniform1i (GLint location, GLint v0);
void uniform2fv(GLint location, GLsizei count, const GLfloat* v0);
void vertexAttribPointer (GLuint index, GLint size, GLenum type, 
    GLboolean normalized, GLsizei stride, const GLvoid *pointer);
void enableVertexAttribArray(GLuint index);
GLint getAttribLocation (GLuint program, const GLchar *name);
GLint getUniformLocation (GLuint program, const GLchar *name);
GLuint createProgram (void);
void uniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose,
    const GLfloat *value);
void uniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose,
    const GLfloat *value);
void uniform1f (GLint location, GLfloat v0);
void attachShader (GLuint program, GLuint shader);
void linkProgram(GLuint program);
void getProgramiv(GLuint program, GLenum pname, GLint* params);
void getProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length,
    GLchar *infoLog);

#endif /* GLSHADERFUNCTIONMAPPING_H */