Update goldfish from aosp/master

    Merge aosp/master fixes into lmp-dev

    This patch updates the goldfish device to match the following
    patches:
        1c9492dd Fix GPU emulation crash.
        1da62b8c opengl: Fix a few function name typos.
        a4d0e1ca opengl: Remove accessor functions from encoders.
        223a765d opengl: Remove compiler warnings.
        b7837c3c opengl: Regenerate GPU emulation encoder sources.
        622970b4 opengl: Fix 64-bit build.
        5fa17220 Unbind buffer when buffer is deleted
        4a01a642 Properly initialize GLClientState's m_states
        2c71ccd4 handles glGetBooleanv when value is nonboolean
        4f9ec391 Fix eglDestroyContext and glTexImage2D
        585a4b03 opengl: Fix pixelDataSize() ambiguity.

Change-Id: I3f574149558b4b4cee8a3e354314f6da8f49957d

37 files changed, 2247 insertions, 3156 deletions

diff --git a/opengl/README b/opengl/README
index 91050ed..3303d4b 100644
--- a/opengl/README
+++ b/opengl/README
@@ -1,3 +1,19 @@
 This directory contains Android-side modules related to hardware OpenGL ES
 emulation. The host-side modules and documentation are in
 $ANDROID_BUILD_TOP/sdk/emulator/opengl.
+
+Note that this directory contains encoder sources that are auto-generated
+with the 'emugen' host tool (see sdk/emulator/opengl/host/tools/emugen).
+
+To regenerate them, run external/qemu/distrib/update-emugl-sources.sh,
+after building the emulator from sources, this will populate the content
+here with the appropriate updated source files.
+
+You should do this whenever you update one of the *.types, *.in and *.attrib
+files located under one of:
+
+  $AOSP/sdk/emulator/opengl/libs/GLESv1_dec/
+  $AOSP/sdk/emulator/opengl/libs/GLESv2_dec/
+  $AOSP/sdk/emulator/opengl/libs/renderControl_dec/
+
+or when the 'emugen' tool itself is modified.
diff --git a/opengl/shared/OpenglCodecCommon/FixedBuffer.h b/opengl/shared/OpenglCodecCommon/FixedBuffer.h
index 30b9a80..7026396 100644
--- a/opengl/shared/OpenglCodecCommon/FixedBuffer.h
+++ b/opengl/shared/OpenglCodecCommon/FixedBuffer.h
@@ -20,7 +20,7 @@ class FixedBuffer {
 public:
     FixedBuffer(size_t initialSize = 0) {
         m_buffer = NULL;
-        m_bufferLen = 0;
+        m_bufferLen = initialSize;
         alloc(m_bufferLen);
     }
 
diff --git a/opengl/shared/OpenglCodecCommon/GLClientState.cpp b/opengl/shared/OpenglCodecCommon/GLClientState.cpp
index a84e856..0826a14 100644
--- a/opengl/shared/OpenglCodecCommon/GLClientState.cpp
+++ b/opengl/shared/OpenglCodecCommon/GLClientState.cpp
@@ -35,6 +35,7 @@ GLClientState::GLClientState(int nLocations)
     for (int i = 0; i < m_nLocations; i++) {
         m_states[i].enabled = 0;
         m_states[i].enableDirty = false;
+        m_states[i].data = 0;
     }
     m_currentArrayVbo = 0;
     m_currentIndexVbo = 0;
diff --git a/opengl/shared/OpenglCodecCommon/GLClientState.h b/opengl/shared/OpenglCodecCommon/GLClientState.h
index c86329b..09ee571 100644
--- a/opengl/shared/OpenglCodecCommon/GLClientState.h
+++ b/opengl/shared/OpenglCodecCommon/GLClientState.h
@@ -91,6 +91,12 @@ public:
     void setActiveTexture(int texUnit) {m_activeTexture = texUnit; };
     int getActiveTexture() const { return m_activeTexture; }
 
+    void unBindBuffer(GLuint id)
+    {
+        if (m_currentArrayVbo == id) m_currentArrayVbo = 0;
+        else if (m_currentIndexVbo == id) m_currentIndexVbo = 0;
+    }
+
     int bindBuffer(GLenum target, GLuint id)
     {
         int err = 0;
diff --git a/opengl/system/GLESv1/gl.cpp b/opengl/system/GLESv1/gl.cpp
index 8ecb504..a7950eb 100644
--- a/opengl/system/GLESv1/gl.cpp
+++ b/opengl/system/GLESv1/gl.cpp
@@ -50,6 +50,8 @@ static EGLClient_glesInterface * s_gl = NULL;
 //GL extensions
 void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES image)
 {
+    (void)self;
+
     DBG("glEGLImageTargetTexture2DOES v1 target=%#x image=%p", target, image);
     //TODO: check error - we don't have a way to set gl error
     android_native_buffer_t* native_buffer = (android_native_buffer_t*)image;
@@ -75,6 +77,9 @@ void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES imag
 
 void glEGLImageTargetRenderbufferStorageOES(void *self, GLenum target, GLeglImageOES image)
 {
+    (void)self;
+    (void)target;
+
     DBG("glEGLImageTargetRenderbufferStorageOES v1 target=%#x image=%p",
             target, image);
     //TODO: check error - we don't have a way to set gl error
@@ -113,6 +118,8 @@ void finish()
 
 const GLubyte *my_glGetString (void *self, GLenum name)
 {
+    (void)self;
+
     if (s_egl) {
         return (const GLubyte*)s_egl->getGLString(name);
     }
@@ -122,9 +129,9 @@ const GLubyte *my_glGetString (void *self, GLenum name)
 void init()
 {
     GET_CONTEXT;
-    ctx->set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES);
-    ctx->set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES);
-    ctx->set_glGetString(my_glGetString);
+    ctx->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES;
+    ctx->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES;
+    ctx->glGetString = &my_glGetString;
 }
 
 extern "C" {
diff --git a/opengl/system/GLESv1_enc/GLEncoder.cpp b/opengl/system/GLESv1_enc/GLEncoder.cpp
index 989c26f..0fe1d8e 100644
--- a/opengl/system/GLESv1_enc/GLEncoder.cpp
+++ b/opengl/system/GLESv1_enc/GLEncoder.cpp
@@ -235,6 +235,8 @@ void GLEncoder::s_glFlush(void *self)
 
 const GLubyte *GLEncoder::s_glGetString(void *self, GLenum name)
 {
+    (void)self;
+
     GLubyte *retval =  (GLubyte *) "";
     switch(name) {
     case GL_VENDOR:
@@ -282,7 +284,7 @@ void GLEncoder::s_glColorPointer(void *self, int size, GLenum type, GLsizei stri
     ctx->m_state->setState(GLClientState::COLOR_LOCATION, size, type, false, stride, data);
 }
 
-void GLEncoder::s_glPointsizePointer(void *self, GLenum type, GLsizei stride, const void *data)
+void GLEncoder::s_glPointSizePointerOES(void *self, GLenum type, GLsizei stride, const void *data)
 {
     GLEncoder *ctx = (GLEncoder *)self;
     assert(ctx->m_state != NULL);
@@ -296,7 +298,7 @@ void GLEncoder::s_glClientActiveTexture(void *self, GLenum texture)
     ctx->m_state->setActiveTexture(texture - GL_TEXTURE0);
 }
 
-void GLEncoder::s_glTexcoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data)
+void GLEncoder::s_glTexCoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data)
 {
     GLEncoder *ctx = (GLEncoder *)self;
     assert(ctx->m_state != NULL);
@@ -923,52 +925,56 @@ GLEncoder::GLEncoder(IOStream *stream) : gl_encoder_context_t(stream)
     m_error = GL_NO_ERROR;
     m_num_compressedTextureFormats = 0;
     m_compressedTextureFormats = NULL;
+
     // overrides;
-    m_glFlush_enc = set_glFlush(s_glFlush);
-    m_glPixelStorei_enc = set_glPixelStorei(s_glPixelStorei);
-    m_glVertexPointer_enc = set_glVertexPointer(s_glVertexPointer);
-    m_glNormalPointer_enc = set_glNormalPointer(s_glNormalPointer);
-    m_glColorPointer_enc = set_glColorPointer(s_glColorPointer);
-    m_glPointSizePointerOES_enc = set_glPointSizePointerOES(s_glPointsizePointer);
-    m_glClientActiveTexture_enc = set_glClientActiveTexture(s_glClientActiveTexture);
-    m_glTexCoordPointer_enc = set_glTexCoordPointer(s_glTexcoordPointer);
-    m_glMatrixIndexPointerOES_enc = set_glMatrixIndexPointerOES(s_glMatrixIndexPointerOES);
-    m_glWeightPointerOES_enc = set_glWeightPointerOES(s_glWeightPointerOES);
-
-    m_glGetIntegerv_enc = set_glGetIntegerv(s_glGetIntegerv);
-    m_glGetFloatv_enc = set_glGetFloatv(s_glGetFloatv);
-    m_glGetBooleanv_enc = set_glGetBooleanv(s_glGetBooleanv);
-    m_glGetFixedv_enc = set_glGetFixedv(s_glGetFixedv);
-    m_glGetPointerv_enc = set_glGetPointerv(s_glGetPointerv);
-
-    m_glBindBuffer_enc = set_glBindBuffer(s_glBindBuffer);
-    m_glBufferData_enc = set_glBufferData(s_glBufferData);
-    m_glBufferSubData_enc = set_glBufferSubData(s_glBufferSubData);
-    m_glDeleteBuffers_enc = set_glDeleteBuffers(s_glDeleteBuffers);
-
-    m_glEnableClientState_enc = set_glEnableClientState(s_glEnableClientState);
-    m_glDisableClientState_enc = set_glDisableClientState(s_glDisableClientState);
-    m_glIsEnabled_enc = set_glIsEnabled(s_glIsEnabled);
-    m_glDrawArrays_enc = set_glDrawArrays(s_glDrawArrays);
-    m_glDrawElements_enc = set_glDrawElements(s_glDrawElements);
-    set_glGetString(s_glGetString);
-    set_glFinish(s_glFinish);
-    m_glGetError_enc = set_glGetError(s_glGetError);
-
-    m_glActiveTexture_enc = set_glActiveTexture(s_glActiveTexture);
-    m_glBindTexture_enc = set_glBindTexture(s_glBindTexture);
-    m_glDeleteTextures_enc = set_glDeleteTextures(s_glDeleteTextures);
-    m_glDisable_enc = set_glDisable(s_glDisable);
-    m_glEnable_enc = set_glEnable(s_glEnable);
-    m_glGetTexParameterfv_enc = set_glGetTexParameterfv(s_glGetTexParameterfv);
-    m_glGetTexParameteriv_enc = set_glGetTexParameteriv(s_glGetTexParameteriv);
-    m_glGetTexParameterxv_enc = set_glGetTexParameterxv(s_glGetTexParameterxv);
-    m_glTexParameterf_enc = set_glTexParameterf(s_glTexParameterf);
-    m_glTexParameterfv_enc = set_glTexParameterfv(s_glTexParameterfv);
-    m_glTexParameteri_enc = set_glTexParameteri(s_glTexParameteri);
-    m_glTexParameterx_enc = set_glTexParameterx(s_glTexParameterx);
-    m_glTexParameteriv_enc = set_glTexParameteriv(s_glTexParameteriv);
-    m_glTexParameterxv_enc = set_glTexParameterxv(s_glTexParameterxv);
+#define OVERRIDE(name)  m_##name##_enc = this-> name ; this-> name = &s_##name
+
+    OVERRIDE(glFlush);
+    OVERRIDE(glPixelStorei);
+    OVERRIDE(glVertexPointer);
+    OVERRIDE(glNormalPointer);
+    OVERRIDE(glPointSizePointerOES);
+    OVERRIDE(glClientActiveTexture);
+    OVERRIDE(glTexCoordPointer);
+    OVERRIDE(glMatrixIndexPointerOES);
+    OVERRIDE(glWeightPointerOES);
+
+    OVERRIDE(glGetIntegerv);
+    OVERRIDE(glGetFloatv);
+    OVERRIDE(glGetBooleanv);
+    OVERRIDE(glGetFixedv);
+    OVERRIDE(glGetPointerv);
+
+    OVERRIDE(glBindBuffer);
+    OVERRIDE(glBufferData);
+    OVERRIDE(glBufferSubData);
+    OVERRIDE(glDeleteBuffers);
+
+    OVERRIDE(glEnableClientState);
+    OVERRIDE(glDisableClientState);
+    OVERRIDE(glIsEnabled);
+    OVERRIDE(glDrawArrays);
+    OVERRIDE(glDrawElements);
+
+    this->glGetString = s_glGetString;
+    this->glFinish = s_glFinish;
+
+    OVERRIDE(glGetError);
+
+    OVERRIDE(glActiveTexture);
+    OVERRIDE(glBindTexture);
+    OVERRIDE(glDeleteTextures);
+    OVERRIDE(glDisable);
+    OVERRIDE(glEnable);
+    OVERRIDE(glGetTexParameterfv);
+    OVERRIDE(glGetTexParameteriv);
+    OVERRIDE(glGetTexParameterxv);
+    OVERRIDE(glTexParameterf);
+    OVERRIDE(glTexParameterfv);
+    OVERRIDE(glTexParameteri);
+    OVERRIDE(glTexParameterx);
+    OVERRIDE(glTexParameteriv);
+    OVERRIDE(glTexParameterxv);
 }
 
 GLEncoder::~GLEncoder()
diff --git a/opengl/system/GLESv1_enc/GLEncoder.h b/opengl/system/GLESv1_enc/GLEncoder.h
index effc53f..3c794f2 100644
--- a/opengl/system/GLESv1_enc/GLEncoder.h
+++ b/opengl/system/GLESv1_enc/GLEncoder.h
@@ -111,9 +111,9 @@ private:
     static void s_glVertexPointer(void *self, int size, GLenum type, GLsizei stride, const void *data);
     static void s_glNormalPointer(void *self, GLenum type, GLsizei stride, const void *data);
     static void s_glColorPointer(void *self, int size, GLenum type, GLsizei stride, const void *data);
-    static void s_glPointsizePointer(void *self, GLenum type, GLsizei stride, const void *data);
+    static void s_glPointSizePointerOES(void *self, GLenum type, GLsizei stride, const void *data);
     static void s_glClientActiveTexture(void *self, GLenum texture);
-    static void s_glTexcoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data);
+    static void s_glTexCoordPointer(void *self, int size, GLenum type, GLsizei stride, const void *data);
     static void s_glMatrixIndexPointerOES(void *self, int size, GLenum type, GLsizei stride, const void * data);
     static void s_glWeightPointerOES(void *self, int size, GLenum type, GLsizei stride, const void * data);
     static void s_glDisableClientState(void *self, GLenum state);
diff --git a/opengl/system/GLESv1_enc/GLEncoderUtils.cpp b/opengl/system/GLESv1_enc/GLEncoderUtils.cpp
index 7866d53..4924392 100644
--- a/opengl/system/GLESv1_enc/GLEncoderUtils.cpp
+++ b/opengl/system/GLESv1_enc/GLEncoderUtils.cpp
@@ -17,8 +17,12 @@
 #include <stdlib.h>
 #include "GLEncoder.h"
 
+namespace glesv1_enc {
+
 size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack)
 {
     GLEncoder *ctx = (GLEncoder *)self;
     return ctx->pixelDataSize(width, height, format, type, pack);
 }
+
+}  // namespace glesv1_enc
diff --git a/opengl/system/GLESv1_enc/GLEncoderUtils.h b/opengl/system/GLESv1_enc/GLEncoderUtils.h
index 1d0c847..05cc9e1 100644
--- a/opengl/system/GLESv1_enc/GLEncoderUtils.h
+++ b/opengl/system/GLESv1_enc/GLEncoderUtils.h
@@ -16,7 +16,8 @@
 #ifndef GL_ENCODER_UTILS_H
 #define GL_ENCLODER_UTILS_H
 
-extern "C" {
+namespace glesv1_enc {
     size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack);
 };
+
 #endif
diff --git a/opengl/system/GLESv1_enc/gl_client_context.cpp b/opengl/system/GLESv1_enc/gl_client_context.cpp
index a5fd04b..cb504c8 100644
--- a/opengl/system/GLESv1_enc/gl_client_context.cpp
+++ b/opengl/system/GLESv1_enc/gl_client_context.cpp
@@ -10,299 +10,297 @@
 
 int gl_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData)
 {
-	void *ptr;
-
-	ptr = getProc("glAlphaFunc", userData); set_glAlphaFunc((glAlphaFunc_client_proc_t)ptr);
-	ptr = getProc("glClearColor", userData); set_glClearColor((glClearColor_client_proc_t)ptr);
-	ptr = getProc("glClearDepthf", userData); set_glClearDepthf((glClearDepthf_client_proc_t)ptr);
-	ptr = getProc("glClipPlanef", userData); set_glClipPlanef((glClipPlanef_client_proc_t)ptr);
-	ptr = getProc("glColor4f", userData); set_glColor4f((glColor4f_client_proc_t)ptr);
-	ptr = getProc("glDepthRangef", userData); set_glDepthRangef((glDepthRangef_client_proc_t)ptr);
-	ptr = getProc("glFogf", userData); set_glFogf((glFogf_client_proc_t)ptr);
-	ptr = getProc("glFogfv", userData); set_glFogfv((glFogfv_client_proc_t)ptr);
-	ptr = getProc("glFrustumf", userData); set_glFrustumf((glFrustumf_client_proc_t)ptr);
-	ptr = getProc("glGetClipPlanef", userData); set_glGetClipPlanef((glGetClipPlanef_client_proc_t)ptr);
-	ptr = getProc("glGetFloatv", userData); set_glGetFloatv((glGetFloatv_client_proc_t)ptr);
-	ptr = getProc("glGetLightfv", userData); set_glGetLightfv((glGetLightfv_client_proc_t)ptr);
-	ptr = getProc("glGetMaterialfv", userData); set_glGetMaterialfv((glGetMaterialfv_client_proc_t)ptr);
-	ptr = getProc("glGetTexEnvfv", userData); set_glGetTexEnvfv((glGetTexEnvfv_client_proc_t)ptr);
-	ptr = getProc("glGetTexParameterfv", userData); set_glGetTexParameterfv((glGetTexParameterfv_client_proc_t)ptr);
-	ptr = getProc("glLightModelf", userData); set_glLightModelf((glLightModelf_client_proc_t)ptr);
-	ptr = getProc("glLightModelfv", userData); set_glLightModelfv((glLightModelfv_client_proc_t)ptr);
-	ptr = getProc("glLightf", userData); set_glLightf((glLightf_client_proc_t)ptr);
-	ptr = getProc("glLightfv", userData); set_glLightfv((glLightfv_client_proc_t)ptr);
-	ptr = getProc("glLineWidth", userData); set_glLineWidth((glLineWidth_client_proc_t)ptr);
-	ptr = getProc("glLoadMatrixf", userData); set_glLoadMatrixf((glLoadMatrixf_client_proc_t)ptr);
-	ptr = getProc("glMaterialf", userData); set_glMaterialf((glMaterialf_client_proc_t)ptr);
-	ptr = getProc("glMaterialfv", userData); set_glMaterialfv((glMaterialfv_client_proc_t)ptr);
-	ptr = getProc("glMultMatrixf", userData); set_glMultMatrixf((glMultMatrixf_client_proc_t)ptr);
-	ptr = getProc("glMultiTexCoord4f", userData); set_glMultiTexCoord4f((glMultiTexCoord4f_client_proc_t)ptr);
-	ptr = getProc("glNormal3f", userData); set_glNormal3f((glNormal3f_client_proc_t)ptr);
-	ptr = getProc("glOrthof", userData); set_glOrthof((glOrthof_client_proc_t)ptr);
-	ptr = getProc("glPointParameterf", userData); set_glPointParameterf((glPointParameterf_client_proc_t)ptr);
-	ptr = getProc("glPointParameterfv", userData); set_glPointParameterfv((glPointParameterfv_client_proc_t)ptr);
-	ptr = getProc("glPointSize", userData); set_glPointSize((glPointSize_client_proc_t)ptr);
-	ptr = getProc("glPolygonOffset", userData); set_glPolygonOffset((glPolygonOffset_client_proc_t)ptr);
-	ptr = getProc("glRotatef", userData); set_glRotatef((glRotatef_client_proc_t)ptr);
-	ptr = getProc("glScalef", userData); set_glScalef((glScalef_client_proc_t)ptr);
-	ptr = getProc("glTexEnvf", userData); set_glTexEnvf((glTexEnvf_client_proc_t)ptr);
-	ptr = getProc("glTexEnvfv", userData); set_glTexEnvfv((glTexEnvfv_client_proc_t)ptr);
-	ptr = getProc("glTexParameterf", userData); set_glTexParameterf((glTexParameterf_client_proc_t)ptr);
-	ptr = getProc("glTexParameterfv", userData); set_glTexParameterfv((glTexParameterfv_client_proc_t)ptr);
-	ptr = getProc("glTranslatef", userData); set_glTranslatef((glTranslatef_client_proc_t)ptr);
-	ptr = getProc("glActiveTexture", userData); set_glActiveTexture((glActiveTexture_client_proc_t)ptr);
-	ptr = getProc("glAlphaFuncx", userData); set_glAlphaFuncx((glAlphaFuncx_client_proc_t)ptr);
-	ptr = getProc("glBindBuffer", userData); set_glBindBuffer((glBindBuffer_client_proc_t)ptr);
-	ptr = getProc("glBindTexture", userData); set_glBindTexture((glBindTexture_client_proc_t)ptr);
-	ptr = getProc("glBlendFunc", userData); set_glBlendFunc((glBlendFunc_client_proc_t)ptr);
-	ptr = getProc("glBufferData", userData); set_glBufferData((glBufferData_client_proc_t)ptr);
-	ptr = getProc("glBufferSubData", userData); set_glBufferSubData((glBufferSubData_client_proc_t)ptr);
-	ptr = getProc("glClear", userData); set_glClear((glClear_client_proc_t)ptr);
-	ptr = getProc("glClearColorx", userData); set_glClearColorx((glClearColorx_client_proc_t)ptr);
-	ptr = getProc("glClearDepthx", userData); set_glClearDepthx((glClearDepthx_client_proc_t)ptr);
-	ptr = getProc("glClearStencil", userData); set_glClearStencil((glClearStencil_client_proc_t)ptr);
-	ptr = getProc("glClientActiveTexture", userData); set_glClientActiveTexture((glClientActiveTexture_client_proc_t)ptr);
-	ptr = getProc("glColor4ub", userData); set_glColor4ub((glColor4ub_client_proc_t)ptr);
-	ptr = getProc("glColor4x", userData); set_glColor4x((glColor4x_client_proc_t)ptr);
-	ptr = getProc("glColorMask", userData); set_glColorMask((glColorMask_client_proc_t)ptr);
-	ptr = getProc("glColorPointer", userData); set_glColorPointer((glColorPointer_client_proc_t)ptr);
-	ptr = getProc("glCompressedTexImage2D", userData); set_glCompressedTexImage2D((glCompressedTexImage2D_client_proc_t)ptr);
-	ptr = getProc("glCompressedTexSubImage2D", userData); set_glCompressedTexSubImage2D((glCompressedTexSubImage2D_client_proc_t)ptr);
-	ptr = getProc("glCopyTexImage2D", userData); set_glCopyTexImage2D((glCopyTexImage2D_client_proc_t)ptr);
-	ptr = getProc("glCopyTexSubImage2D", userData); set_glCopyTexSubImage2D((glCopyTexSubImage2D_client_proc_t)ptr);
-	ptr = getProc("glCullFace", userData); set_glCullFace((glCullFace_client_proc_t)ptr);
-	ptr = getProc("glDeleteBuffers", userData); set_glDeleteBuffers((glDeleteBuffers_client_proc_t)ptr);
-	ptr = getProc("glDeleteTextures", userData); set_glDeleteTextures((glDeleteTextures_client_proc_t)ptr);
-	ptr = getProc("glDepthFunc", userData); set_glDepthFunc((glDepthFunc_client_proc_t)ptr);
-	ptr = getProc("glDepthMask", userData); set_glDepthMask((glDepthMask_client_proc_t)ptr);
-	ptr = getProc("glDepthRangex", userData); set_glDepthRangex((glDepthRangex_client_proc_t)ptr);
-	ptr = getProc("glDisable", userData); set_glDisable((glDisable_client_proc_t)ptr);
-	ptr = getProc("glDisableClientState", userData); set_glDisableClientState((glDisableClientState_client_proc_t)ptr);
-	ptr = getProc("glDrawArrays", userData); set_glDrawArrays((glDrawArrays_client_proc_t)ptr);
-	ptr = getProc("glDrawElements", userData); set_glDrawElements((glDrawElements_client_proc_t)ptr);
-	ptr = getProc("glEnable", userData); set_glEnable((glEnable_client_proc_t)ptr);
-	ptr = getProc("glEnableClientState", userData); set_glEnableClientState((glEnableClientState_client_proc_t)ptr);
-	ptr = getProc("glFinish", userData); set_glFinish((glFinish_client_proc_t)ptr);
-	ptr = getProc("glFlush", userData); set_glFlush((glFlush_client_proc_t)ptr);
-	ptr = getProc("glFogx", userData); set_glFogx((glFogx_client_proc_t)ptr);
-	ptr = getProc("glFogxv", userData); set_glFogxv((glFogxv_client_proc_t)ptr);
-	ptr = getProc("glFrontFace", userData); set_glFrontFace((glFrontFace_client_proc_t)ptr);
-	ptr = getProc("glFrustumx", userData); set_glFrustumx((glFrustumx_client_proc_t)ptr);
-	ptr = getProc("glGetBooleanv", userData); set_glGetBooleanv((glGetBooleanv_client_proc_t)ptr);
-	ptr = getProc("glGetBufferParameteriv", userData); set_glGetBufferParameteriv((glGetBufferParameteriv_client_proc_t)ptr);
-	ptr = getProc("glClipPlanex", userData); set_glClipPlanex((glClipPlanex_client_proc_t)ptr);
-	ptr = getProc("glGenBuffers", userData); set_glGenBuffers((glGenBuffers_client_proc_t)ptr);
-	ptr = getProc("glGenTextures", userData); set_glGenTextures((glGenTextures_client_proc_t)ptr);
-	ptr = getProc("glGetError", userData); set_glGetError((glGetError_client_proc_t)ptr);
-	ptr = getProc("glGetFixedv", userData); set_glGetFixedv((glGetFixedv_client_proc_t)ptr);
-	ptr = getProc("glGetIntegerv", userData); set_glGetIntegerv((glGetIntegerv_client_proc_t)ptr);
-	ptr = getProc("glGetLightxv", userData); set_glGetLightxv((glGetLightxv_client_proc_t)ptr);
-	ptr = getProc("glGetMaterialxv", userData); set_glGetMaterialxv((glGetMaterialxv_client_proc_t)ptr);
-	ptr = getProc("glGetPointerv", userData); set_glGetPointerv((glGetPointerv_client_proc_t)ptr);
-	ptr = getProc("glGetString", userData); set_glGetString((glGetString_client_proc_t)ptr);
-	ptr = getProc("glGetTexEnviv", userData); set_glGetTexEnviv((glGetTexEnviv_client_proc_t)ptr);
-	ptr = getProc("glGetTexEnvxv", userData); set_glGetTexEnvxv((glGetTexEnvxv_client_proc_t)ptr);
-	ptr = getProc("glGetTexParameteriv", userData); set_glGetTexParameteriv((glGetTexParameteriv_client_proc_t)ptr);
-	ptr = getProc("glGetTexParameterxv", userData); set_glGetTexParameterxv((glGetTexParameterxv_client_proc_t)ptr);
-	ptr = getProc("glHint", userData); set_glHint((glHint_client_proc_t)ptr);
-	ptr = getProc("glIsBuffer", userData); set_glIsBuffer((glIsBuffer_client_proc_t)ptr);
-	ptr = getProc("glIsEnabled", userData); set_glIsEnabled((glIsEnabled_client_proc_t)ptr);
-	ptr = getProc("glIsTexture", userData); set_glIsTexture((glIsTexture_client_proc_t)ptr);
-	ptr = getProc("glLightModelx", userData); set_glLightModelx((glLightModelx_client_proc_t)ptr);
-	ptr = getProc("glLightModelxv", userData); set_glLightModelxv((glLightModelxv_client_proc_t)ptr);
-	ptr = getProc("glLightx", userData); set_glLightx((glLightx_client_proc_t)ptr);
-	ptr = getProc("glLightxv", userData); set_glLightxv((glLightxv_client_proc_t)ptr);
-	ptr = getProc("glLineWidthx", userData); set_glLineWidthx((glLineWidthx_client_proc_t)ptr);
-	ptr = getProc("glLoadIdentity", userData); set_glLoadIdentity((glLoadIdentity_client_proc_t)ptr);
-	ptr = getProc("glLoadMatrixx", userData); set_glLoadMatrixx((glLoadMatrixx_client_proc_t)ptr);
-	ptr = getProc("glLogicOp", userData); set_glLogicOp((glLogicOp_client_proc_t)ptr);
-	ptr = getProc("glMaterialx", userData); set_glMaterialx((glMaterialx_client_proc_t)ptr);
-	ptr = getProc("glMaterialxv", userData); set_glMaterialxv((glMaterialxv_client_proc_t)ptr);
-	ptr = getProc("glMatrixMode", userData); set_glMatrixMode((glMatrixMode_client_proc_t)ptr);
-	ptr = getProc("glMultMatrixx", userData); set_glMultMatrixx((glMultMatrixx_client_proc_t)ptr);
-	ptr = getProc("glMultiTexCoord4x", userData); set_glMultiTexCoord4x((glMultiTexCoord4x_client_proc_t)ptr);
-	ptr = getProc("glNormal3x", userData); set_glNormal3x((glNormal3x_client_proc_t)ptr);
-	ptr = getProc("glNormalPointer", userData); set_glNormalPointer((glNormalPointer_client_proc_t)ptr);
-	ptr = getProc("glOrthox", userData); set_glOrthox((glOrthox_client_proc_t)ptr);
-	ptr = getProc("glPixelStorei", userData); set_glPixelStorei((glPixelStorei_client_proc_t)ptr);
-	ptr = getProc("glPointParameterx", userData); set_glPointParameterx((glPointParameterx_client_proc_t)ptr);
-	ptr = getProc("glPointParameterxv", userData); set_glPointParameterxv((glPointParameterxv_client_proc_t)ptr);
-	ptr = getProc("glPointSizex", userData); set_glPointSizex((glPointSizex_client_proc_t)ptr);
-	ptr = getProc("glPolygonOffsetx", userData); set_glPolygonOffsetx((glPolygonOffsetx_client_proc_t)ptr);
-	ptr = getProc("glPopMatrix", userData); set_glPopMatrix((glPopMatrix_client_proc_t)ptr);
-	ptr = getProc("glPushMatrix", userData); set_glPushMatrix((glPushMatrix_client_proc_t)ptr);
-	ptr = getProc("glReadPixels", userData); set_glReadPixels((glReadPixels_client_proc_t)ptr);
-	ptr = getProc("glRotatex", userData); set_glRotatex((glRotatex_client_proc_t)ptr);
-	ptr = getProc("glSampleCoverage", userData); set_glSampleCoverage((glSampleCoverage_client_proc_t)ptr);
-	ptr = getProc("glSampleCoveragex", userData); set_glSampleCoveragex((glSampleCoveragex_client_proc_t)ptr);
-	ptr = getProc("glScalex", userData); set_glScalex((glScalex_client_proc_t)ptr);
-	ptr = getProc("glScissor", userData); set_glScissor((glScissor_client_proc_t)ptr);
-	ptr = getProc("glShadeModel", userData); set_glShadeModel((glShadeModel_client_proc_t)ptr);
-	ptr = getProc("glStencilFunc", userData); set_glStencilFunc((glStencilFunc_client_proc_t)ptr);
-	ptr = getProc("glStencilMask", userData); set_glStencilMask((glStencilMask_client_proc_t)ptr);
-	ptr = getProc("glStencilOp", userData); set_glStencilOp((glStencilOp_client_proc_t)ptr);
-	ptr = getProc("glTexCoordPointer", userData); set_glTexCoordPointer((glTexCoordPointer_client_proc_t)ptr);
-	ptr = getProc("glTexEnvi", userData); set_glTexEnvi((glTexEnvi_client_proc_t)ptr);
-	ptr = getProc("glTexEnvx", userData); set_glTexEnvx((glTexEnvx_client_proc_t)ptr);
-	ptr = getProc("glTexEnviv", userData); set_glTexEnviv((glTexEnviv_client_proc_t)ptr);
-	ptr = getProc("glTexEnvxv", userData); set_glTexEnvxv((glTexEnvxv_client_proc_t)ptr);
-	ptr = getProc("glTexImage2D", userData); set_glTexImage2D((glTexImage2D_client_proc_t)ptr);
-	ptr = getProc("glTexParameteri", userData); set_glTexParameteri((glTexParameteri_client_proc_t)ptr);
-	ptr = getProc("glTexParameterx", userData); set_glTexParameterx((glTexParameterx_client_proc_t)ptr);
-	ptr = getProc("glTexParameteriv", userData); set_glTexParameteriv((glTexParameteriv_client_proc_t)ptr);
-	ptr = getProc("glTexParameterxv", userData); set_glTexParameterxv((glTexParameterxv_client_proc_t)ptr);
-	ptr = getProc("glTexSubImage2D", userData); set_glTexSubImage2D((glTexSubImage2D_client_proc_t)ptr);
-	ptr = getProc("glTranslatex", userData); set_glTranslatex((glTranslatex_client_proc_t)ptr);
-	ptr = getProc("glVertexPointer", userData); set_glVertexPointer((glVertexPointer_client_proc_t)ptr);
-	ptr = getProc("glViewport", userData); set_glViewport((glViewport_client_proc_t)ptr);
-	ptr = getProc("glPointSizePointerOES", userData); set_glPointSizePointerOES((glPointSizePointerOES_client_proc_t)ptr);
-	ptr = getProc("glVertexPointerOffset", userData); set_glVertexPointerOffset((glVertexPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glColorPointerOffset", userData); set_glColorPointerOffset((glColorPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glNormalPointerOffset", userData); set_glNormalPointerOffset((glNormalPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glPointSizePointerOffset", userData); set_glPointSizePointerOffset((glPointSizePointerOffset_client_proc_t)ptr);
-	ptr = getProc("glTexCoordPointerOffset", userData); set_glTexCoordPointerOffset((glTexCoordPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glWeightPointerOffset", userData); set_glWeightPointerOffset((glWeightPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glMatrixIndexPointerOffset", userData); set_glMatrixIndexPointerOffset((glMatrixIndexPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glVertexPointerData", userData); set_glVertexPointerData((glVertexPointerData_client_proc_t)ptr);
-	ptr = getProc("glColorPointerData", userData); set_glColorPointerData((glColorPointerData_client_proc_t)ptr);
-	ptr = getProc("glNormalPointerData", userData); set_glNormalPointerData((glNormalPointerData_client_proc_t)ptr);
-	ptr = getProc("glTexCoordPointerData", userData); set_glTexCoordPointerData((glTexCoordPointerData_client_proc_t)ptr);
-	ptr = getProc("glPointSizePointerData", userData); set_glPointSizePointerData((glPointSizePointerData_client_proc_t)ptr);
-	ptr = getProc("glWeightPointerData", userData); set_glWeightPointerData((glWeightPointerData_client_proc_t)ptr);
-	ptr = getProc("glMatrixIndexPointerData", userData); set_glMatrixIndexPointerData((glMatrixIndexPointerData_client_proc_t)ptr);
-	ptr = getProc("glDrawElementsOffset", userData); set_glDrawElementsOffset((glDrawElementsOffset_client_proc_t)ptr);
-	ptr = getProc("glDrawElementsData", userData); set_glDrawElementsData((glDrawElementsData_client_proc_t)ptr);
-	ptr = getProc("glGetCompressedTextureFormats", userData); set_glGetCompressedTextureFormats((glGetCompressedTextureFormats_client_proc_t)ptr);
-	ptr = getProc("glFinishRoundTrip", userData); set_glFinishRoundTrip((glFinishRoundTrip_client_proc_t)ptr);
-	ptr = getProc("glBlendEquationSeparateOES", userData); set_glBlendEquationSeparateOES((glBlendEquationSeparateOES_client_proc_t)ptr);
-	ptr = getProc("glBlendFuncSeparateOES", userData); set_glBlendFuncSeparateOES((glBlendFuncSeparateOES_client_proc_t)ptr);
-	ptr = getProc("glBlendEquationOES", userData); set_glBlendEquationOES((glBlendEquationOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexsOES", userData); set_glDrawTexsOES((glDrawTexsOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexiOES", userData); set_glDrawTexiOES((glDrawTexiOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexxOES", userData); set_glDrawTexxOES((glDrawTexxOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexsvOES", userData); set_glDrawTexsvOES((glDrawTexsvOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexivOES", userData); set_glDrawTexivOES((glDrawTexivOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexxvOES", userData); set_glDrawTexxvOES((glDrawTexxvOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexfOES", userData); set_glDrawTexfOES((glDrawTexfOES_client_proc_t)ptr);
-	ptr = getProc("glDrawTexfvOES", userData); set_glDrawTexfvOES((glDrawTexfvOES_client_proc_t)ptr);
-	ptr = getProc("glEGLImageTargetTexture2DOES", userData); set_glEGLImageTargetTexture2DOES((glEGLImageTargetTexture2DOES_client_proc_t)ptr);
-	ptr = getProc("glEGLImageTargetRenderbufferStorageOES", userData); set_glEGLImageTargetRenderbufferStorageOES((glEGLImageTargetRenderbufferStorageOES_client_proc_t)ptr);
-	ptr = getProc("glAlphaFuncxOES", userData); set_glAlphaFuncxOES((glAlphaFuncxOES_client_proc_t)ptr);
-	ptr = getProc("glClearColorxOES", userData); set_glClearColorxOES((glClearColorxOES_client_proc_t)ptr);
-	ptr = getProc("glClearDepthxOES", userData); set_glClearDepthxOES((glClearDepthxOES_client_proc_t)ptr);
-	ptr = getProc("glClipPlanexOES", userData); set_glClipPlanexOES((glClipPlanexOES_client_proc_t)ptr);
-	ptr = getProc("glClipPlanexIMG", userData); set_glClipPlanexIMG((glClipPlanexIMG_client_proc_t)ptr);
-	ptr = getProc("glColor4xOES", userData); set_glColor4xOES((glColor4xOES_client_proc_t)ptr);
-	ptr = getProc("glDepthRangexOES", userData); set_glDepthRangexOES((glDepthRangexOES_client_proc_t)ptr);
-	ptr = getProc("glFogxOES", userData); set_glFogxOES((glFogxOES_client_proc_t)ptr);
-	ptr = getProc("glFogxvOES", userData); set_glFogxvOES((glFogxvOES_client_proc_t)ptr);
-	ptr = getProc("glFrustumxOES", userData); set_glFrustumxOES((glFrustumxOES_client_proc_t)ptr);
-	ptr = getProc("glGetClipPlanexOES", userData); set_glGetClipPlanexOES((glGetClipPlanexOES_client_proc_t)ptr);
-	ptr = getProc("glGetClipPlanex", userData); set_glGetClipPlanex((glGetClipPlanex_client_proc_t)ptr);
-	ptr = getProc("glGetFixedvOES", userData); set_glGetFixedvOES((glGetFixedvOES_client_proc_t)ptr);
-	ptr = getProc("glGetLightxvOES", userData); set_glGetLightxvOES((glGetLightxvOES_client_proc_t)ptr);
-	ptr = getProc("glGetMaterialxvOES", userData); set_glGetMaterialxvOES((glGetMaterialxvOES_client_proc_t)ptr);
-	ptr = getProc("glGetTexEnvxvOES", userData); set_glGetTexEnvxvOES((glGetTexEnvxvOES_client_proc_t)ptr);
-	ptr = getProc("glGetTexParameterxvOES", userData); set_glGetTexParameterxvOES((glGetTexParameterxvOES_client_proc_t)ptr);
-	ptr = getProc("glLightModelxOES", userData); set_glLightModelxOES((glLightModelxOES_client_proc_t)ptr);
-	ptr = getProc("glLightModelxvOES", userData); set_glLightModelxvOES((glLightModelxvOES_client_proc_t)ptr);
-	ptr = getProc("glLightxOES", userData); set_glLightxOES((glLightxOES_client_proc_t)ptr);
-	ptr = getProc("glLightxvOES", userData); set_glLightxvOES((glLightxvOES_client_proc_t)ptr);
-	ptr = getProc("glLineWidthxOES", userData); set_glLineWidthxOES((glLineWidthxOES_client_proc_t)ptr);
-	ptr = getProc("glLoadMatrixxOES", userData); set_glLoadMatrixxOES((glLoadMatrixxOES_client_proc_t)ptr);
-	ptr = getProc("glMaterialxOES", userData); set_glMaterialxOES((glMaterialxOES_client_proc_t)ptr);
-	ptr = getProc("glMaterialxvOES", userData); set_glMaterialxvOES((glMaterialxvOES_client_proc_t)ptr);
-	ptr = getProc("glMultMatrixxOES", userData); set_glMultMatrixxOES((glMultMatrixxOES_client_proc_t)ptr);
-	ptr = getProc("glMultiTexCoord4xOES", userData); set_glMultiTexCoord4xOES((glMultiTexCoord4xOES_client_proc_t)ptr);
-	ptr = getProc("glNormal3xOES", userData); set_glNormal3xOES((glNormal3xOES_client_proc_t)ptr);
-	ptr = getProc("glOrthoxOES", userData); set_glOrthoxOES((glOrthoxOES_client_proc_t)ptr);
-	ptr = getProc("glPointParameterxOES", userData); set_glPointParameterxOES((glPointParameterxOES_client_proc_t)ptr);
-	ptr = getProc("glPointParameterxvOES", userData); set_glPointParameterxvOES((glPointParameterxvOES_client_proc_t)ptr);
-	ptr = getProc("glPointSizexOES", userData); set_glPointSizexOES((glPointSizexOES_client_proc_t)ptr);
-	ptr = getProc("glPolygonOffsetxOES", userData); set_glPolygonOffsetxOES((glPolygonOffsetxOES_client_proc_t)ptr);
-	ptr = getProc("glRotatexOES", userData); set_glRotatexOES((glRotatexOES_client_proc_t)ptr);
-	ptr = getProc("glSampleCoveragexOES", userData); set_glSampleCoveragexOES((glSampleCoveragexOES_client_proc_t)ptr);
-	ptr = getProc("glScalexOES", userData); set_glScalexOES((glScalexOES_client_proc_t)ptr);
-	ptr = getProc("glTexEnvxOES", userData); set_glTexEnvxOES((glTexEnvxOES_client_proc_t)ptr);
-	ptr = getProc("glTexEnvxvOES", userData); set_glTexEnvxvOES((glTexEnvxvOES_client_proc_t)ptr);
-	ptr = getProc("glTexParameterxOES", userData); set_glTexParameterxOES((glTexParameterxOES_client_proc_t)ptr);
-	ptr = getProc("glTexParameterxvOES", userData); set_glTexParameterxvOES((glTexParameterxvOES_client_proc_t)ptr);
-	ptr = getProc("glTranslatexOES", userData); set_glTranslatexOES((glTranslatexOES_client_proc_t)ptr);
-	ptr = getProc("glIsRenderbufferOES", userData); set_glIsRenderbufferOES((glIsRenderbufferOES_client_proc_t)ptr);
-	ptr = getProc("glBindRenderbufferOES", userData); set_glBindRenderbufferOES((glBindRenderbufferOES_client_proc_t)ptr);
-	ptr = getProc("glDeleteRenderbuffersOES", userData); set_glDeleteRenderbuffersOES((glDeleteRenderbuffersOES_client_proc_t)ptr);
-	ptr = getProc("glGenRenderbuffersOES", userData); set_glGenRenderbuffersOES((glGenRenderbuffersOES_client_proc_t)ptr);
-	ptr = getProc("glRenderbufferStorageOES", userData); set_glRenderbufferStorageOES((glRenderbufferStorageOES_client_proc_t)ptr);
-	ptr = getProc("glGetRenderbufferParameterivOES", userData); set_glGetRenderbufferParameterivOES((glGetRenderbufferParameterivOES_client_proc_t)ptr);
-	ptr = getProc("glIsFramebufferOES", userData); set_glIsFramebufferOES((glIsFramebufferOES_client_proc_t)ptr);
-	ptr = getProc("glBindFramebufferOES", userData); set_glBindFramebufferOES((glBindFramebufferOES_client_proc_t)ptr);
-	ptr = getProc("glDeleteFramebuffersOES", userData); set_glDeleteFramebuffersOES((glDeleteFramebuffersOES_client_proc_t)ptr);
-	ptr = getProc("glGenFramebuffersOES", userData); set_glGenFramebuffersOES((glGenFramebuffersOES_client_proc_t)ptr);
-	ptr = getProc("glCheckFramebufferStatusOES", userData); set_glCheckFramebufferStatusOES((glCheckFramebufferStatusOES_client_proc_t)ptr);
-	ptr = getProc("glFramebufferRenderbufferOES", userData); set_glFramebufferRenderbufferOES((glFramebufferRenderbufferOES_client_proc_t)ptr);
-	ptr = getProc("glFramebufferTexture2DOES", userData); set_glFramebufferTexture2DOES((glFramebufferTexture2DOES_client_proc_t)ptr);
-	ptr = getProc("glGetFramebufferAttachmentParameterivOES", userData); set_glGetFramebufferAttachmentParameterivOES((glGetFramebufferAttachmentParameterivOES_client_proc_t)ptr);
-	ptr = getProc("glGenerateMipmapOES", userData); set_glGenerateMipmapOES((glGenerateMipmapOES_client_proc_t)ptr);
-	ptr = getProc("glMapBufferOES", userData); set_glMapBufferOES((glMapBufferOES_client_proc_t)ptr);
-	ptr = getProc("glUnmapBufferOES", userData); set_glUnmapBufferOES((glUnmapBufferOES_client_proc_t)ptr);
-	ptr = getProc("glGetBufferPointervOES", userData); set_glGetBufferPointervOES((glGetBufferPointervOES_client_proc_t)ptr);
-	ptr = getProc("glCurrentPaletteMatrixOES", userData); set_glCurrentPaletteMatrixOES((glCurrentPaletteMatrixOES_client_proc_t)ptr);
-	ptr = getProc("glLoadPaletteFromModelViewMatrixOES", userData); set_glLoadPaletteFromModelViewMatrixOES((glLoadPaletteFromModelViewMatrixOES_client_proc_t)ptr);
-	ptr = getProc("glMatrixIndexPointerOES", userData); set_glMatrixIndexPointerOES((glMatrixIndexPointerOES_client_proc_t)ptr);
-	ptr = getProc("glWeightPointerOES", userData); set_glWeightPointerOES((glWeightPointerOES_client_proc_t)ptr);
-	ptr = getProc("glQueryMatrixxOES", userData); set_glQueryMatrixxOES((glQueryMatrixxOES_client_proc_t)ptr);
-	ptr = getProc("glDepthRangefOES", userData); set_glDepthRangefOES((glDepthRangefOES_client_proc_t)ptr);
-	ptr = getProc("glFrustumfOES", userData); set_glFrustumfOES((glFrustumfOES_client_proc_t)ptr);
-	ptr = getProc("glOrthofOES", userData); set_glOrthofOES((glOrthofOES_client_proc_t)ptr);
-	ptr = getProc("glClipPlanefOES", userData); set_glClipPlanefOES((glClipPlanefOES_client_proc_t)ptr);
-	ptr = getProc("glClipPlanefIMG", userData); set_glClipPlanefIMG((glClipPlanefIMG_client_proc_t)ptr);
-	ptr = getProc("glGetClipPlanefOES", userData); set_glGetClipPlanefOES((glGetClipPlanefOES_client_proc_t)ptr);
-	ptr = getProc("glClearDepthfOES", userData); set_glClearDepthfOES((glClearDepthfOES_client_proc_t)ptr);
-	ptr = getProc("glTexGenfOES", userData); set_glTexGenfOES((glTexGenfOES_client_proc_t)ptr);
-	ptr = getProc("glTexGenfvOES", userData); set_glTexGenfvOES((glTexGenfvOES_client_proc_t)ptr);
-	ptr = getProc("glTexGeniOES", userData); set_glTexGeniOES((glTexGeniOES_client_proc_t)ptr);
-	ptr = getProc("glTexGenivOES", userData); set_glTexGenivOES((glTexGenivOES_client_proc_t)ptr);
-	ptr = getProc("glTexGenxOES", userData); set_glTexGenxOES((glTexGenxOES_client_proc_t)ptr);
-	ptr = getProc("glTexGenxvOES", userData); set_glTexGenxvOES((glTexGenxvOES_client_proc_t)ptr);
-	ptr = getProc("glGetTexGenfvOES", userData); set_glGetTexGenfvOES((glGetTexGenfvOES_client_proc_t)ptr);
-	ptr = getProc("glGetTexGenivOES", userData); set_glGetTexGenivOES((glGetTexGenivOES_client_proc_t)ptr);
-	ptr = getProc("glGetTexGenxvOES", userData); set_glGetTexGenxvOES((glGetTexGenxvOES_client_proc_t)ptr);
-	ptr = getProc("glBindVertexArrayOES", userData); set_glBindVertexArrayOES((glBindVertexArrayOES_client_proc_t)ptr);
-	ptr = getProc("glDeleteVertexArraysOES", userData); set_glDeleteVertexArraysOES((glDeleteVertexArraysOES_client_proc_t)ptr);
-	ptr = getProc("glGenVertexArraysOES", userData); set_glGenVertexArraysOES((glGenVertexArraysOES_client_proc_t)ptr);
-	ptr = getProc("glIsVertexArrayOES", userData); set_glIsVertexArrayOES((glIsVertexArrayOES_client_proc_t)ptr);
-	ptr = getProc("glDiscardFramebufferEXT", userData); set_glDiscardFramebufferEXT((glDiscardFramebufferEXT_client_proc_t)ptr);
-	ptr = getProc("glMultiDrawArraysEXT", userData); set_glMultiDrawArraysEXT((glMultiDrawArraysEXT_client_proc_t)ptr);
-	ptr = getProc("glMultiDrawElementsEXT", userData); set_glMultiDrawElementsEXT((glMultiDrawElementsEXT_client_proc_t)ptr);
-	ptr = getProc("glMultiDrawArraysSUN", userData); set_glMultiDrawArraysSUN((glMultiDrawArraysSUN_client_proc_t)ptr);
-	ptr = getProc("glMultiDrawElementsSUN", userData); set_glMultiDrawElementsSUN((glMultiDrawElementsSUN_client_proc_t)ptr);
-	ptr = getProc("glRenderbufferStorageMultisampleIMG", userData); set_glRenderbufferStorageMultisampleIMG((glRenderbufferStorageMultisampleIMG_client_proc_t)ptr);
-	ptr = getProc("glFramebufferTexture2DMultisampleIMG", userData); set_glFramebufferTexture2DMultisampleIMG((glFramebufferTexture2DMultisampleIMG_client_proc_t)ptr);
-	ptr = getProc("glDeleteFencesNV", userData); set_glDeleteFencesNV((glDeleteFencesNV_client_proc_t)ptr);
-	ptr = getProc("glGenFencesNV", userData); set_glGenFencesNV((glGenFencesNV_client_proc_t)ptr);
-	ptr = getProc("glIsFenceNV", userData); set_glIsFenceNV((glIsFenceNV_client_proc_t)ptr);
-	ptr = getProc("glTestFenceNV", userData); set_glTestFenceNV((glTestFenceNV_client_proc_t)ptr);
-	ptr = getProc("glGetFenceivNV", userData); set_glGetFenceivNV((glGetFenceivNV_client_proc_t)ptr);
-	ptr = getProc("glFinishFenceNV", userData); set_glFinishFenceNV((glFinishFenceNV_client_proc_t)ptr);
-	ptr = getProc("glSetFenceNV", userData); set_glSetFenceNV((glSetFenceNV_client_proc_t)ptr);
-	ptr = getProc("glGetDriverControlsQCOM", userData); set_glGetDriverControlsQCOM((glGetDriverControlsQCOM_client_proc_t)ptr);
-	ptr = getProc("glGetDriverControlStringQCOM", userData); set_glGetDriverControlStringQCOM((glGetDriverControlStringQCOM_client_proc_t)ptr);
-	ptr = getProc("glEnableDriverControlQCOM", userData); set_glEnableDriverControlQCOM((glEnableDriverControlQCOM_client_proc_t)ptr);
-	ptr = getProc("glDisableDriverControlQCOM", userData); set_glDisableDriverControlQCOM((glDisableDriverControlQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetTexturesQCOM", userData); set_glExtGetTexturesQCOM((glExtGetTexturesQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetBuffersQCOM", userData); set_glExtGetBuffersQCOM((glExtGetBuffersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetRenderbuffersQCOM", userData); set_glExtGetRenderbuffersQCOM((glExtGetRenderbuffersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetFramebuffersQCOM", userData); set_glExtGetFramebuffersQCOM((glExtGetFramebuffersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetTexLevelParameterivQCOM", userData); set_glExtGetTexLevelParameterivQCOM((glExtGetTexLevelParameterivQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtTexObjectStateOverrideiQCOM", userData); set_glExtTexObjectStateOverrideiQCOM((glExtTexObjectStateOverrideiQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetTexSubImageQCOM", userData); set_glExtGetTexSubImageQCOM((glExtGetTexSubImageQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetBufferPointervQCOM", userData); set_glExtGetBufferPointervQCOM((glExtGetBufferPointervQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetShadersQCOM", userData); set_glExtGetShadersQCOM((glExtGetShadersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetProgramsQCOM", userData); set_glExtGetProgramsQCOM((glExtGetProgramsQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtIsProgramBinaryQCOM", userData); set_glExtIsProgramBinaryQCOM((glExtIsProgramBinaryQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetProgramBinarySourceQCOM", userData); set_glExtGetProgramBinarySourceQCOM((glExtGetProgramBinarySourceQCOM_client_proc_t)ptr);
-	ptr = getProc("glStartTilingQCOM", userData); set_glStartTilingQCOM((glStartTilingQCOM_client_proc_t)ptr);
-	ptr = getProc("glEndTilingQCOM", userData); set_glEndTilingQCOM((glEndTilingQCOM_client_proc_t)ptr);
+	glAlphaFunc = (glAlphaFunc_client_proc_t) getProc("glAlphaFunc", userData);
+	glClearColor = (glClearColor_client_proc_t) getProc("glClearColor", userData);
+	glClearDepthf = (glClearDepthf_client_proc_t) getProc("glClearDepthf", userData);
+	glClipPlanef = (glClipPlanef_client_proc_t) getProc("glClipPlanef", userData);
+	glColor4f = (glColor4f_client_proc_t) getProc("glColor4f", userData);
+	glDepthRangef = (glDepthRangef_client_proc_t) getProc("glDepthRangef", userData);
+	glFogf = (glFogf_client_proc_t) getProc("glFogf", userData);
+	glFogfv = (glFogfv_client_proc_t) getProc("glFogfv", userData);
+	glFrustumf = (glFrustumf_client_proc_t) getProc("glFrustumf", userData);
+	glGetClipPlanef = (glGetClipPlanef_client_proc_t) getProc("glGetClipPlanef", userData);
+	glGetFloatv = (glGetFloatv_client_proc_t) getProc("glGetFloatv", userData);
+	glGetLightfv = (glGetLightfv_client_proc_t) getProc("glGetLightfv", userData);
+	glGetMaterialfv = (glGetMaterialfv_client_proc_t) getProc("glGetMaterialfv", userData);
+	glGetTexEnvfv = (glGetTexEnvfv_client_proc_t) getProc("glGetTexEnvfv", userData);
+	glGetTexParameterfv = (glGetTexParameterfv_client_proc_t) getProc("glGetTexParameterfv", userData);
+	glLightModelf = (glLightModelf_client_proc_t) getProc("glLightModelf", userData);
+	glLightModelfv = (glLightModelfv_client_proc_t) getProc("glLightModelfv", userData);
+	glLightf = (glLightf_client_proc_t) getProc("glLightf", userData);
+	glLightfv = (glLightfv_client_proc_t) getProc("glLightfv", userData);
+	glLineWidth = (glLineWidth_client_proc_t) getProc("glLineWidth", userData);
+	glLoadMatrixf = (glLoadMatrixf_client_proc_t) getProc("glLoadMatrixf", userData);
+	glMaterialf = (glMaterialf_client_proc_t) getProc("glMaterialf", userData);
+	glMaterialfv = (glMaterialfv_client_proc_t) getProc("glMaterialfv", userData);
+	glMultMatrixf = (glMultMatrixf_client_proc_t) getProc("glMultMatrixf", userData);
+	glMultiTexCoord4f = (glMultiTexCoord4f_client_proc_t) getProc("glMultiTexCoord4f", userData);
+	glNormal3f = (glNormal3f_client_proc_t) getProc("glNormal3f", userData);
+	glOrthof = (glOrthof_client_proc_t) getProc("glOrthof", userData);
+	glPointParameterf = (glPointParameterf_client_proc_t) getProc("glPointParameterf", userData);
+	glPointParameterfv = (glPointParameterfv_client_proc_t) getProc("glPointParameterfv", userData);
+	glPointSize = (glPointSize_client_proc_t) getProc("glPointSize", userData);
+	glPolygonOffset = (glPolygonOffset_client_proc_t) getProc("glPolygonOffset", userData);
+	glRotatef = (glRotatef_client_proc_t) getProc("glRotatef", userData);
+	glScalef = (glScalef_client_proc_t) getProc("glScalef", userData);
+	glTexEnvf = (glTexEnvf_client_proc_t) getProc("glTexEnvf", userData);
+	glTexEnvfv = (glTexEnvfv_client_proc_t) getProc("glTexEnvfv", userData);
+	glTexParameterf = (glTexParameterf_client_proc_t) getProc("glTexParameterf", userData);
+	glTexParameterfv = (glTexParameterfv_client_proc_t) getProc("glTexParameterfv", userData);
+	glTranslatef = (glTranslatef_client_proc_t) getProc("glTranslatef", userData);
+	glActiveTexture = (glActiveTexture_client_proc_t) getProc("glActiveTexture", userData);
+	glAlphaFuncx = (glAlphaFuncx_client_proc_t) getProc("glAlphaFuncx", userData);
+	glBindBuffer = (glBindBuffer_client_proc_t) getProc("glBindBuffer", userData);
+	glBindTexture = (glBindTexture_client_proc_t) getProc("glBindTexture", userData);
+	glBlendFunc = (glBlendFunc_client_proc_t) getProc("glBlendFunc", userData);
+	glBufferData = (glBufferData_client_proc_t) getProc("glBufferData", userData);
+	glBufferSubData = (glBufferSubData_client_proc_t) getProc("glBufferSubData", userData);
+	glClear = (glClear_client_proc_t) getProc("glClear", userData);
+	glClearColorx = (glClearColorx_client_proc_t) getProc("glClearColorx", userData);
+	glClearDepthx = (glClearDepthx_client_proc_t) getProc("glClearDepthx", userData);
+	glClearStencil = (glClearStencil_client_proc_t) getProc("glClearStencil", userData);
+	glClientActiveTexture = (glClientActiveTexture_client_proc_t) getProc("glClientActiveTexture", userData);
+	glColor4ub = (glColor4ub_client_proc_t) getProc("glColor4ub", userData);
+	glColor4x = (glColor4x_client_proc_t) getProc("glColor4x", userData);
+	glColorMask = (glColorMask_client_proc_t) getProc("glColorMask", userData);
+	glColorPointer = (glColorPointer_client_proc_t) getProc("glColorPointer", userData);
+	glCompressedTexImage2D = (glCompressedTexImage2D_client_proc_t) getProc("glCompressedTexImage2D", userData);
+	glCompressedTexSubImage2D = (glCompressedTexSubImage2D_client_proc_t) getProc("glCompressedTexSubImage2D", userData);
+	glCopyTexImage2D = (glCopyTexImage2D_client_proc_t) getProc("glCopyTexImage2D", userData);
+	glCopyTexSubImage2D = (glCopyTexSubImage2D_client_proc_t) getProc("glCopyTexSubImage2D", userData);
+	glCullFace = (glCullFace_client_proc_t) getProc("glCullFace", userData);
+	glDeleteBuffers = (glDeleteBuffers_client_proc_t) getProc("glDeleteBuffers", userData);
+	glDeleteTextures = (glDeleteTextures_client_proc_t) getProc("glDeleteTextures", userData);
+	glDepthFunc = (glDepthFunc_client_proc_t) getProc("glDepthFunc", userData);
+	glDepthMask = (glDepthMask_client_proc_t) getProc("glDepthMask", userData);
+	glDepthRangex = (glDepthRangex_client_proc_t) getProc("glDepthRangex", userData);
+	glDisable = (glDisable_client_proc_t) getProc("glDisable", userData);
+	glDisableClientState = (glDisableClientState_client_proc_t) getProc("glDisableClientState", userData);
+	glDrawArrays = (glDrawArrays_client_proc_t) getProc("glDrawArrays", userData);
+	glDrawElements = (glDrawElements_client_proc_t) getProc("glDrawElements", userData);
+	glEnable = (glEnable_client_proc_t) getProc("glEnable", userData);
+	glEnableClientState = (glEnableClientState_client_proc_t) getProc("glEnableClientState", userData);
+	glFinish = (glFinish_client_proc_t) getProc("glFinish", userData);
+	glFlush = (glFlush_client_proc_t) getProc("glFlush", userData);
+	glFogx = (glFogx_client_proc_t) getProc("glFogx", userData);
+	glFogxv = (glFogxv_client_proc_t) getProc("glFogxv", userData);
+	glFrontFace = (glFrontFace_client_proc_t) getProc("glFrontFace", userData);
+	glFrustumx = (glFrustumx_client_proc_t) getProc("glFrustumx", userData);
+	glGetBooleanv = (glGetBooleanv_client_proc_t) getProc("glGetBooleanv", userData);
+	glGetBufferParameteriv = (glGetBufferParameteriv_client_proc_t) getProc("glGetBufferParameteriv", userData);
+	glClipPlanex = (glClipPlanex_client_proc_t) getProc("glClipPlanex", userData);
+	glGenBuffers = (glGenBuffers_client_proc_t) getProc("glGenBuffers", userData);
+	glGenTextures = (glGenTextures_client_proc_t) getProc("glGenTextures", userData);
+	glGetError = (glGetError_client_proc_t) getProc("glGetError", userData);
+	glGetFixedv = (glGetFixedv_client_proc_t) getProc("glGetFixedv", userData);
+	glGetIntegerv = (glGetIntegerv_client_proc_t) getProc("glGetIntegerv", userData);
+	glGetLightxv = (glGetLightxv_client_proc_t) getProc("glGetLightxv", userData);
+	glGetMaterialxv = (glGetMaterialxv_client_proc_t) getProc("glGetMaterialxv", userData);
+	glGetPointerv = (glGetPointerv_client_proc_t) getProc("glGetPointerv", userData);
+	glGetString = (glGetString_client_proc_t) getProc("glGetString", userData);
+	glGetTexEnviv = (glGetTexEnviv_client_proc_t) getProc("glGetTexEnviv", userData);
+	glGetTexEnvxv = (glGetTexEnvxv_client_proc_t) getProc("glGetTexEnvxv", userData);
+	glGetTexParameteriv = (glGetTexParameteriv_client_proc_t) getProc("glGetTexParameteriv", userData);
+	glGetTexParameterxv = (glGetTexParameterxv_client_proc_t) getProc("glGetTexParameterxv", userData);
+	glHint = (glHint_client_proc_t) getProc("glHint", userData);
+	glIsBuffer = (glIsBuffer_client_proc_t) getProc("glIsBuffer", userData);
+	glIsEnabled = (glIsEnabled_client_proc_t) getProc("glIsEnabled", userData);
+	glIsTexture = (glIsTexture_client_proc_t) getProc("glIsTexture", userData);
+	glLightModelx = (glLightModelx_client_proc_t) getProc("glLightModelx", userData);
+	glLightModelxv = (glLightModelxv_client_proc_t) getProc("glLightModelxv", userData);
+	glLightx = (glLightx_client_proc_t) getProc("glLightx", userData);
+	glLightxv = (glLightxv_client_proc_t) getProc("glLightxv", userData);
+	glLineWidthx = (glLineWidthx_client_proc_t) getProc("glLineWidthx", userData);
+	glLoadIdentity = (glLoadIdentity_client_proc_t) getProc("glLoadIdentity", userData);
+	glLoadMatrixx = (glLoadMatrixx_client_proc_t) getProc("glLoadMatrixx", userData);
+	glLogicOp = (glLogicOp_client_proc_t) getProc("glLogicOp", userData);
+	glMaterialx = (glMaterialx_client_proc_t) getProc("glMaterialx", userData);
+	glMaterialxv = (glMaterialxv_client_proc_t) getProc("glMaterialxv", userData);
+	glMatrixMode = (glMatrixMode_client_proc_t) getProc("glMatrixMode", userData);
+	glMultMatrixx = (glMultMatrixx_client_proc_t) getProc("glMultMatrixx", userData);
+	glMultiTexCoord4x = (glMultiTexCoord4x_client_proc_t) getProc("glMultiTexCoord4x", userData);
+	glNormal3x = (glNormal3x_client_proc_t) getProc("glNormal3x", userData);
+	glNormalPointer = (glNormalPointer_client_proc_t) getProc("glNormalPointer", userData);
+	glOrthox = (glOrthox_client_proc_t) getProc("glOrthox", userData);
+	glPixelStorei = (glPixelStorei_client_proc_t) getProc("glPixelStorei", userData);
+	glPointParameterx = (glPointParameterx_client_proc_t) getProc("glPointParameterx", userData);
+	glPointParameterxv = (glPointParameterxv_client_proc_t) getProc("glPointParameterxv", userData);
+	glPointSizex = (glPointSizex_client_proc_t) getProc("glPointSizex", userData);
+	glPolygonOffsetx = (glPolygonOffsetx_client_proc_t) getProc("glPolygonOffsetx", userData);
+	glPopMatrix = (glPopMatrix_client_proc_t) getProc("glPopMatrix", userData);
+	glPushMatrix = (glPushMatrix_client_proc_t) getProc("glPushMatrix", userData);
+	glReadPixels = (glReadPixels_client_proc_t) getProc("glReadPixels", userData);
+	glRotatex = (glRotatex_client_proc_t) getProc("glRotatex", userData);
+	glSampleCoverage = (glSampleCoverage_client_proc_t) getProc("glSampleCoverage", userData);
+	glSampleCoveragex = (glSampleCoveragex_client_proc_t) getProc("glSampleCoveragex", userData);
+	glScalex = (glScalex_client_proc_t) getProc("glScalex", userData);
+	glScissor = (glScissor_client_proc_t) getProc("glScissor", userData);
+	glShadeModel = (glShadeModel_client_proc_t) getProc("glShadeModel", userData);
+	glStencilFunc = (glStencilFunc_client_proc_t) getProc("glStencilFunc", userData);
+	glStencilMask = (glStencilMask_client_proc_t) getProc("glStencilMask", userData);
+	glStencilOp = (glStencilOp_client_proc_t) getProc("glStencilOp", userData);
+	glTexCoordPointer = (glTexCoordPointer_client_proc_t) getProc("glTexCoordPointer", userData);
+	glTexEnvi = (glTexEnvi_client_proc_t) getProc("glTexEnvi", userData);
+	glTexEnvx = (glTexEnvx_client_proc_t) getProc("glTexEnvx", userData);
+	glTexEnviv = (glTexEnviv_client_proc_t) getProc("glTexEnviv", userData);
+	glTexEnvxv = (glTexEnvxv_client_proc_t) getProc("glTexEnvxv", userData);
+	glTexImage2D = (glTexImage2D_client_proc_t) getProc("glTexImage2D", userData);
+	glTexParameteri = (glTexParameteri_client_proc_t) getProc("glTexParameteri", userData);
+	glTexParameterx = (glTexParameterx_client_proc_t) getProc("glTexParameterx", userData);
+	glTexParameteriv = (glTexParameteriv_client_proc_t) getProc("glTexParameteriv", userData);
+	glTexParameterxv = (glTexParameterxv_client_proc_t) getProc("glTexParameterxv", userData);
+	glTexSubImage2D = (glTexSubImage2D_client_proc_t) getProc("glTexSubImage2D", userData);
+	glTranslatex = (glTranslatex_client_proc_t) getProc("glTranslatex", userData);
+	glVertexPointer = (glVertexPointer_client_proc_t) getProc("glVertexPointer", userData);
+	glViewport = (glViewport_client_proc_t) getProc("glViewport", userData);
+	glPointSizePointerOES = (glPointSizePointerOES_client_proc_t) getProc("glPointSizePointerOES", userData);
+	glVertexPointerOffset = (glVertexPointerOffset_client_proc_t) getProc("glVertexPointerOffset", userData);
+	glColorPointerOffset = (glColorPointerOffset_client_proc_t) getProc("glColorPointerOffset", userData);
+	glNormalPointerOffset = (glNormalPointerOffset_client_proc_t) getProc("glNormalPointerOffset", userData);
+	glPointSizePointerOffset = (glPointSizePointerOffset_client_proc_t) getProc("glPointSizePointerOffset", userData);
+	glTexCoordPointerOffset = (glTexCoordPointerOffset_client_proc_t) getProc("glTexCoordPointerOffset", userData);
+	glWeightPointerOffset = (glWeightPointerOffset_client_proc_t) getProc("glWeightPointerOffset", userData);
+	glMatrixIndexPointerOffset = (glMatrixIndexPointerOffset_client_proc_t) getProc("glMatrixIndexPointerOffset", userData);
+	glVertexPointerData = (glVertexPointerData_client_proc_t) getProc("glVertexPointerData", userData);
+	glColorPointerData = (glColorPointerData_client_proc_t) getProc("glColorPointerData", userData);
+	glNormalPointerData = (glNormalPointerData_client_proc_t) getProc("glNormalPointerData", userData);
+	glTexCoordPointerData = (glTexCoordPointerData_client_proc_t) getProc("glTexCoordPointerData", userData);
+	glPointSizePointerData = (glPointSizePointerData_client_proc_t) getProc("glPointSizePointerData", userData);
+	glWeightPointerData = (glWeightPointerData_client_proc_t) getProc("glWeightPointerData", userData);
+	glMatrixIndexPointerData = (glMatrixIndexPointerData_client_proc_t) getProc("glMatrixIndexPointerData", userData);
+	glDrawElementsOffset = (glDrawElementsOffset_client_proc_t) getProc("glDrawElementsOffset", userData);
+	glDrawElementsData = (glDrawElementsData_client_proc_t) getProc("glDrawElementsData", userData);
+	glGetCompressedTextureFormats = (glGetCompressedTextureFormats_client_proc_t) getProc("glGetCompressedTextureFormats", userData);
+	glFinishRoundTrip = (glFinishRoundTrip_client_proc_t) getProc("glFinishRoundTrip", userData);
+	glBlendEquationSeparateOES = (glBlendEquationSeparateOES_client_proc_t) getProc("glBlendEquationSeparateOES", userData);
+	glBlendFuncSeparateOES = (glBlendFuncSeparateOES_client_proc_t) getProc("glBlendFuncSeparateOES", userData);
+	glBlendEquationOES = (glBlendEquationOES_client_proc_t) getProc("glBlendEquationOES", userData);
+	glDrawTexsOES = (glDrawTexsOES_client_proc_t) getProc("glDrawTexsOES", userData);
+	glDrawTexiOES = (glDrawTexiOES_client_proc_t) getProc("glDrawTexiOES", userData);
+	glDrawTexxOES = (glDrawTexxOES_client_proc_t) getProc("glDrawTexxOES", userData);
+	glDrawTexsvOES = (glDrawTexsvOES_client_proc_t) getProc("glDrawTexsvOES", userData);
+	glDrawTexivOES = (glDrawTexivOES_client_proc_t) getProc("glDrawTexivOES", userData);
+	glDrawTexxvOES = (glDrawTexxvOES_client_proc_t) getProc("glDrawTexxvOES", userData);
+	glDrawTexfOES = (glDrawTexfOES_client_proc_t) getProc("glDrawTexfOES", userData);
+	glDrawTexfvOES = (glDrawTexfvOES_client_proc_t) getProc("glDrawTexfvOES", userData);
+	glEGLImageTargetTexture2DOES = (glEGLImageTargetTexture2DOES_client_proc_t) getProc("glEGLImageTargetTexture2DOES", userData);
+	glEGLImageTargetRenderbufferStorageOES = (glEGLImageTargetRenderbufferStorageOES_client_proc_t) getProc("glEGLImageTargetRenderbufferStorageOES", userData);
+	glAlphaFuncxOES = (glAlphaFuncxOES_client_proc_t) getProc("glAlphaFuncxOES", userData);
+	glClearColorxOES = (glClearColorxOES_client_proc_t) getProc("glClearColorxOES", userData);
+	glClearDepthxOES = (glClearDepthxOES_client_proc_t) getProc("glClearDepthxOES", userData);
+	glClipPlanexOES = (glClipPlanexOES_client_proc_t) getProc("glClipPlanexOES", userData);
+	glClipPlanexIMG = (glClipPlanexIMG_client_proc_t) getProc("glClipPlanexIMG", userData);
+	glColor4xOES = (glColor4xOES_client_proc_t) getProc("glColor4xOES", userData);
+	glDepthRangexOES = (glDepthRangexOES_client_proc_t) getProc("glDepthRangexOES", userData);
+	glFogxOES = (glFogxOES_client_proc_t) getProc("glFogxOES", userData);
+	glFogxvOES = (glFogxvOES_client_proc_t) getProc("glFogxvOES", userData);
+	glFrustumxOES = (glFrustumxOES_client_proc_t) getProc("glFrustumxOES", userData);
+	glGetClipPlanexOES = (glGetClipPlanexOES_client_proc_t) getProc("glGetClipPlanexOES", userData);
+	glGetClipPlanex = (glGetClipPlanex_client_proc_t) getProc("glGetClipPlanex", userData);
+	glGetFixedvOES = (glGetFixedvOES_client_proc_t) getProc("glGetFixedvOES", userData);
+	glGetLightxvOES = (glGetLightxvOES_client_proc_t) getProc("glGetLightxvOES", userData);
+	glGetMaterialxvOES = (glGetMaterialxvOES_client_proc_t) getProc("glGetMaterialxvOES", userData);
+	glGetTexEnvxvOES = (glGetTexEnvxvOES_client_proc_t) getProc("glGetTexEnvxvOES", userData);
+	glGetTexParameterxvOES = (glGetTexParameterxvOES_client_proc_t) getProc("glGetTexParameterxvOES", userData);
+	glLightModelxOES = (glLightModelxOES_client_proc_t) getProc("glLightModelxOES", userData);
+	glLightModelxvOES = (glLightModelxvOES_client_proc_t) getProc("glLightModelxvOES", userData);
+	glLightxOES = (glLightxOES_client_proc_t) getProc("glLightxOES", userData);
+	glLightxvOES = (glLightxvOES_client_proc_t) getProc("glLightxvOES", userData);
+	glLineWidthxOES = (glLineWidthxOES_client_proc_t) getProc("glLineWidthxOES", userData);
+	glLoadMatrixxOES = (glLoadMatrixxOES_client_proc_t) getProc("glLoadMatrixxOES", userData);
+	glMaterialxOES = (glMaterialxOES_client_proc_t) getProc("glMaterialxOES", userData);
+	glMaterialxvOES = (glMaterialxvOES_client_proc_t) getProc("glMaterialxvOES", userData);
+	glMultMatrixxOES = (glMultMatrixxOES_client_proc_t) getProc("glMultMatrixxOES", userData);
+	glMultiTexCoord4xOES = (glMultiTexCoord4xOES_client_proc_t) getProc("glMultiTexCoord4xOES", userData);
+	glNormal3xOES = (glNormal3xOES_client_proc_t) getProc("glNormal3xOES", userData);
+	glOrthoxOES = (glOrthoxOES_client_proc_t) getProc("glOrthoxOES", userData);
+	glPointParameterxOES = (glPointParameterxOES_client_proc_t) getProc("glPointParameterxOES", userData);
+	glPointParameterxvOES = (glPointParameterxvOES_client_proc_t) getProc("glPointParameterxvOES", userData);
+	glPointSizexOES = (glPointSizexOES_client_proc_t) getProc("glPointSizexOES", userData);
+	glPolygonOffsetxOES = (glPolygonOffsetxOES_client_proc_t) getProc("glPolygonOffsetxOES", userData);
+	glRotatexOES = (glRotatexOES_client_proc_t) getProc("glRotatexOES", userData);
+	glSampleCoveragexOES = (glSampleCoveragexOES_client_proc_t) getProc("glSampleCoveragexOES", userData);
+	glScalexOES = (glScalexOES_client_proc_t) getProc("glScalexOES", userData);
+	glTexEnvxOES = (glTexEnvxOES_client_proc_t) getProc("glTexEnvxOES", userData);
+	glTexEnvxvOES = (glTexEnvxvOES_client_proc_t) getProc("glTexEnvxvOES", userData);
+	glTexParameterxOES = (glTexParameterxOES_client_proc_t) getProc("glTexParameterxOES", userData);
+	glTexParameterxvOES = (glTexParameterxvOES_client_proc_t) getProc("glTexParameterxvOES", userData);
+	glTranslatexOES = (glTranslatexOES_client_proc_t) getProc("glTranslatexOES", userData);
+	glIsRenderbufferOES = (glIsRenderbufferOES_client_proc_t) getProc("glIsRenderbufferOES", userData);
+	glBindRenderbufferOES = (glBindRenderbufferOES_client_proc_t) getProc("glBindRenderbufferOES", userData);
+	glDeleteRenderbuffersOES = (glDeleteRenderbuffersOES_client_proc_t) getProc("glDeleteRenderbuffersOES", userData);
+	glGenRenderbuffersOES = (glGenRenderbuffersOES_client_proc_t) getProc("glGenRenderbuffersOES", userData);
+	glRenderbufferStorageOES = (glRenderbufferStorageOES_client_proc_t) getProc("glRenderbufferStorageOES", userData);
+	glGetRenderbufferParameterivOES = (glGetRenderbufferParameterivOES_client_proc_t) getProc("glGetRenderbufferParameterivOES", userData);
+	glIsFramebufferOES = (glIsFramebufferOES_client_proc_t) getProc("glIsFramebufferOES", userData);
+	glBindFramebufferOES = (glBindFramebufferOES_client_proc_t) getProc("glBindFramebufferOES", userData);
+	glDeleteFramebuffersOES = (glDeleteFramebuffersOES_client_proc_t) getProc("glDeleteFramebuffersOES", userData);
+	glGenFramebuffersOES = (glGenFramebuffersOES_client_proc_t) getProc("glGenFramebuffersOES", userData);
+	glCheckFramebufferStatusOES = (glCheckFramebufferStatusOES_client_proc_t) getProc("glCheckFramebufferStatusOES", userData);
+	glFramebufferRenderbufferOES = (glFramebufferRenderbufferOES_client_proc_t) getProc("glFramebufferRenderbufferOES", userData);
+	glFramebufferTexture2DOES = (glFramebufferTexture2DOES_client_proc_t) getProc("glFramebufferTexture2DOES", userData);
+	glGetFramebufferAttachmentParameterivOES = (glGetFramebufferAttachmentParameterivOES_client_proc_t) getProc("glGetFramebufferAttachmentParameterivOES", userData);
+	glGenerateMipmapOES = (glGenerateMipmapOES_client_proc_t) getProc("glGenerateMipmapOES", userData);
+	glMapBufferOES = (glMapBufferOES_client_proc_t) getProc("glMapBufferOES", userData);
+	glUnmapBufferOES = (glUnmapBufferOES_client_proc_t) getProc("glUnmapBufferOES", userData);
+	glGetBufferPointervOES = (glGetBufferPointervOES_client_proc_t) getProc("glGetBufferPointervOES", userData);
+	glCurrentPaletteMatrixOES = (glCurrentPaletteMatrixOES_client_proc_t) getProc("glCurrentPaletteMatrixOES", userData);
+	glLoadPaletteFromModelViewMatrixOES = (glLoadPaletteFromModelViewMatrixOES_client_proc_t) getProc("glLoadPaletteFromModelViewMatrixOES", userData);
+	glMatrixIndexPointerOES = (glMatrixIndexPointerOES_client_proc_t) getProc("glMatrixIndexPointerOES", userData);
+	glWeightPointerOES = (glWeightPointerOES_client_proc_t) getProc("glWeightPointerOES", userData);
+	glQueryMatrixxOES = (glQueryMatrixxOES_client_proc_t) getProc("glQueryMatrixxOES", userData);
+	glDepthRangefOES = (glDepthRangefOES_client_proc_t) getProc("glDepthRangefOES", userData);
+	glFrustumfOES = (glFrustumfOES_client_proc_t) getProc("glFrustumfOES", userData);
+	glOrthofOES = (glOrthofOES_client_proc_t) getProc("glOrthofOES", userData);
+	glClipPlanefOES = (glClipPlanefOES_client_proc_t) getProc("glClipPlanefOES", userData);
+	glClipPlanefIMG = (glClipPlanefIMG_client_proc_t) getProc("glClipPlanefIMG", userData);
+	glGetClipPlanefOES = (glGetClipPlanefOES_client_proc_t) getProc("glGetClipPlanefOES", userData);
+	glClearDepthfOES = (glClearDepthfOES_client_proc_t) getProc("glClearDepthfOES", userData);
+	glTexGenfOES = (glTexGenfOES_client_proc_t) getProc("glTexGenfOES", userData);
+	glTexGenfvOES = (glTexGenfvOES_client_proc_t) getProc("glTexGenfvOES", userData);
+	glTexGeniOES = (glTexGeniOES_client_proc_t) getProc("glTexGeniOES", userData);
+	glTexGenivOES = (glTexGenivOES_client_proc_t) getProc("glTexGenivOES", userData);
+	glTexGenxOES = (glTexGenxOES_client_proc_t) getProc("glTexGenxOES", userData);
+	glTexGenxvOES = (glTexGenxvOES_client_proc_t) getProc("glTexGenxvOES", userData);
+	glGetTexGenfvOES = (glGetTexGenfvOES_client_proc_t) getProc("glGetTexGenfvOES", userData);
+	glGetTexGenivOES = (glGetTexGenivOES_client_proc_t) getProc("glGetTexGenivOES", userData);
+	glGetTexGenxvOES = (glGetTexGenxvOES_client_proc_t) getProc("glGetTexGenxvOES", userData);
+	glBindVertexArrayOES = (glBindVertexArrayOES_client_proc_t) getProc("glBindVertexArrayOES", userData);
+	glDeleteVertexArraysOES = (glDeleteVertexArraysOES_client_proc_t) getProc("glDeleteVertexArraysOES", userData);
+	glGenVertexArraysOES = (glGenVertexArraysOES_client_proc_t) getProc("glGenVertexArraysOES", userData);
+	glIsVertexArrayOES = (glIsVertexArrayOES_client_proc_t) getProc("glIsVertexArrayOES", userData);
+	glDiscardFramebufferEXT = (glDiscardFramebufferEXT_client_proc_t) getProc("glDiscardFramebufferEXT", userData);
+	glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) getProc("glMultiDrawArraysEXT", userData);
+	glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) getProc("glMultiDrawElementsEXT", userData);
+	glMultiDrawArraysSUN = (glMultiDrawArraysSUN_client_proc_t) getProc("glMultiDrawArraysSUN", userData);
+	glMultiDrawElementsSUN = (glMultiDrawElementsSUN_client_proc_t) getProc("glMultiDrawElementsSUN", userData);
+	glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) getProc("glRenderbufferStorageMultisampleIMG", userData);
+	glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) getProc("glFramebufferTexture2DMultisampleIMG", userData);
+	glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) getProc("glDeleteFencesNV", userData);
+	glGenFencesNV = (glGenFencesNV_client_proc_t) getProc("glGenFencesNV", userData);
+	glIsFenceNV = (glIsFenceNV_client_proc_t) getProc("glIsFenceNV", userData);
+	glTestFenceNV = (glTestFenceNV_client_proc_t) getProc("glTestFenceNV", userData);
+	glGetFenceivNV = (glGetFenceivNV_client_proc_t) getProc("glGetFenceivNV", userData);
+	glFinishFenceNV = (glFinishFenceNV_client_proc_t) getProc("glFinishFenceNV", userData);
+	glSetFenceNV = (glSetFenceNV_client_proc_t) getProc("glSetFenceNV", userData);
+	glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) getProc("glGetDriverControlsQCOM", userData);
+	glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) getProc("glGetDriverControlStringQCOM", userData);
+	glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) getProc("glEnableDriverControlQCOM", userData);
+	glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) getProc("glDisableDriverControlQCOM", userData);
+	glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) getProc("glExtGetTexturesQCOM", userData);
+	glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) getProc("glExtGetBuffersQCOM", userData);
+	glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) getProc("glExtGetRenderbuffersQCOM", userData);
+	glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) getProc("glExtGetFramebuffersQCOM", userData);
+	glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) getProc("glExtGetTexLevelParameterivQCOM", userData);
+	glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) getProc("glExtTexObjectStateOverrideiQCOM", userData);
+	glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) getProc("glExtGetTexSubImageQCOM", userData);
+	glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) getProc("glExtGetBufferPointervQCOM", userData);
+	glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) getProc("glExtGetShadersQCOM", userData);
+	glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) getProc("glExtGetProgramsQCOM", userData);
+	glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) getProc("glExtIsProgramBinaryQCOM", userData);
+	glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) getProc("glExtGetProgramBinarySourceQCOM", userData);
+	glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) getProc("glStartTilingQCOM", userData);
+	glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) getProc("glEndTilingQCOM", userData);
 	return 0;
 }
 
diff --git a/opengl/system/GLESv1_enc/gl_client_context.h b/opengl/system/GLESv1_enc/gl_client_context.h
index c0b83ad..35fb27a 100644
--- a/opengl/system/GLESv1_enc/gl_client_context.h
+++ b/opengl/system/GLESv1_enc/gl_client_context.h
@@ -299,304 +299,12 @@ struct gl_client_context_t {
 	glExtGetProgramBinarySourceQCOM_client_proc_t glExtGetProgramBinarySourceQCOM;
 	glStartTilingQCOM_client_proc_t glStartTilingQCOM;
 	glEndTilingQCOM_client_proc_t glEndTilingQCOM;
-	//Accessors 
-	virtual glAlphaFunc_client_proc_t set_glAlphaFunc(glAlphaFunc_client_proc_t f) { glAlphaFunc_client_proc_t retval = glAlphaFunc; glAlphaFunc = f; return retval;}
-	virtual glClearColor_client_proc_t set_glClearColor(glClearColor_client_proc_t f) { glClearColor_client_proc_t retval = glClearColor; glClearColor = f; return retval;}
-	virtual glClearDepthf_client_proc_t set_glClearDepthf(glClearDepthf_client_proc_t f) { glClearDepthf_client_proc_t retval = glClearDepthf; glClearDepthf = f; return retval;}
-	virtual glClipPlanef_client_proc_t set_glClipPlanef(glClipPlanef_client_proc_t f) { glClipPlanef_client_proc_t retval = glClipPlanef; glClipPlanef = f; return retval;}
-	virtual glColor4f_client_proc_t set_glColor4f(glColor4f_client_proc_t f) { glColor4f_client_proc_t retval = glColor4f; glColor4f = f; return retval;}
-	virtual glDepthRangef_client_proc_t set_glDepthRangef(glDepthRangef_client_proc_t f) { glDepthRangef_client_proc_t retval = glDepthRangef; glDepthRangef = f; return retval;}
-	virtual glFogf_client_proc_t set_glFogf(glFogf_client_proc_t f) { glFogf_client_proc_t retval = glFogf; glFogf = f; return retval;}
-	virtual glFogfv_client_proc_t set_glFogfv(glFogfv_client_proc_t f) { glFogfv_client_proc_t retval = glFogfv; glFogfv = f; return retval;}
-	virtual glFrustumf_client_proc_t set_glFrustumf(glFrustumf_client_proc_t f) { glFrustumf_client_proc_t retval = glFrustumf; glFrustumf = f; return retval;}
-	virtual glGetClipPlanef_client_proc_t set_glGetClipPlanef(glGetClipPlanef_client_proc_t f) { glGetClipPlanef_client_proc_t retval = glGetClipPlanef; glGetClipPlanef = f; return retval;}
-	virtual glGetFloatv_client_proc_t set_glGetFloatv(glGetFloatv_client_proc_t f) { glGetFloatv_client_proc_t retval = glGetFloatv; glGetFloatv = f; return retval;}
-	virtual glGetLightfv_client_proc_t set_glGetLightfv(glGetLightfv_client_proc_t f) { glGetLightfv_client_proc_t retval = glGetLightfv; glGetLightfv = f; return retval;}
-	virtual glGetMaterialfv_client_proc_t set_glGetMaterialfv(glGetMaterialfv_client_proc_t f) { glGetMaterialfv_client_proc_t retval = glGetMaterialfv; glGetMaterialfv = f; return retval;}
-	virtual glGetTexEnvfv_client_proc_t set_glGetTexEnvfv(glGetTexEnvfv_client_proc_t f) { glGetTexEnvfv_client_proc_t retval = glGetTexEnvfv; glGetTexEnvfv = f; return retval;}
-	virtual glGetTexParameterfv_client_proc_t set_glGetTexParameterfv(glGetTexParameterfv_client_proc_t f) { glGetTexParameterfv_client_proc_t retval = glGetTexParameterfv; glGetTexParameterfv = f; return retval;}
-	virtual glLightModelf_client_proc_t set_glLightModelf(glLightModelf_client_proc_t f) { glLightModelf_client_proc_t retval = glLightModelf; glLightModelf = f; return retval;}
-	virtual glLightModelfv_client_proc_t set_glLightModelfv(glLightModelfv_client_proc_t f) { glLightModelfv_client_proc_t retval = glLightModelfv; glLightModelfv = f; return retval;}
-	virtual glLightf_client_proc_t set_glLightf(glLightf_client_proc_t f) { glLightf_client_proc_t retval = glLightf; glLightf = f; return retval;}
-	virtual glLightfv_client_proc_t set_glLightfv(glLightfv_client_proc_t f) { glLightfv_client_proc_t retval = glLightfv; glLightfv = f; return retval;}
-	virtual glLineWidth_client_proc_t set_glLineWidth(glLineWidth_client_proc_t f) { glLineWidth_client_proc_t retval = glLineWidth; glLineWidth = f; return retval;}
-	virtual glLoadMatrixf_client_proc_t set_glLoadMatrixf(glLoadMatrixf_client_proc_t f) { glLoadMatrixf_client_proc_t retval = glLoadMatrixf; glLoadMatrixf = f; return retval;}
-	virtual glMaterialf_client_proc_t set_glMaterialf(glMaterialf_client_proc_t f) { glMaterialf_client_proc_t retval = glMaterialf; glMaterialf = f; return retval;}
-	virtual glMaterialfv_client_proc_t set_glMaterialfv(glMaterialfv_client_proc_t f) { glMaterialfv_client_proc_t retval = glMaterialfv; glMaterialfv = f; return retval;}
-	virtual glMultMatrixf_client_proc_t set_glMultMatrixf(glMultMatrixf_client_proc_t f) { glMultMatrixf_client_proc_t retval = glMultMatrixf; glMultMatrixf = f; return retval;}
-	virtual glMultiTexCoord4f_client_proc_t set_glMultiTexCoord4f(glMultiTexCoord4f_client_proc_t f) { glMultiTexCoord4f_client_proc_t retval = glMultiTexCoord4f; glMultiTexCoord4f = f; return retval;}
-	virtual glNormal3f_client_proc_t set_glNormal3f(glNormal3f_client_proc_t f) { glNormal3f_client_proc_t retval = glNormal3f; glNormal3f = f; return retval;}
-	virtual glOrthof_client_proc_t set_glOrthof(glOrthof_client_proc_t f) { glOrthof_client_proc_t retval = glOrthof; glOrthof = f; return retval;}
-	virtual glPointParameterf_client_proc_t set_glPointParameterf(glPointParameterf_client_proc_t f) { glPointParameterf_client_proc_t retval = glPointParameterf; glPointParameterf = f; return retval;}
-	virtual glPointParameterfv_client_proc_t set_glPointParameterfv(glPointParameterfv_client_proc_t f) { glPointParameterfv_client_proc_t retval = glPointParameterfv; glPointParameterfv = f; return retval;}
-	virtual glPointSize_client_proc_t set_glPointSize(glPointSize_client_proc_t f) { glPointSize_client_proc_t retval = glPointSize; glPointSize = f; return retval;}
-	virtual glPolygonOffset_client_proc_t set_glPolygonOffset(glPolygonOffset_client_proc_t f) { glPolygonOffset_client_proc_t retval = glPolygonOffset; glPolygonOffset = f; return retval;}
-	virtual glRotatef_client_proc_t set_glRotatef(glRotatef_client_proc_t f) { glRotatef_client_proc_t retval = glRotatef; glRotatef = f; return retval;}
-	virtual glScalef_client_proc_t set_glScalef(glScalef_client_proc_t f) { glScalef_client_proc_t retval = glScalef; glScalef = f; return retval;}
-	virtual glTexEnvf_client_proc_t set_glTexEnvf(glTexEnvf_client_proc_t f) { glTexEnvf_client_proc_t retval = glTexEnvf; glTexEnvf = f; return retval;}
-	virtual glTexEnvfv_client_proc_t set_glTexEnvfv(glTexEnvfv_client_proc_t f) { glTexEnvfv_client_proc_t retval = glTexEnvfv; glTexEnvfv = f; return retval;}
-	virtual glTexParameterf_client_proc_t set_glTexParameterf(glTexParameterf_client_proc_t f) { glTexParameterf_client_proc_t retval = glTexParameterf; glTexParameterf = f; return retval;}
-	virtual glTexParameterfv_client_proc_t set_glTexParameterfv(glTexParameterfv_client_proc_t f) { glTexParameterfv_client_proc_t retval = glTexParameterfv; glTexParameterfv = f; return retval;}
-	virtual glTranslatef_client_proc_t set_glTranslatef(glTranslatef_client_proc_t f) { glTranslatef_client_proc_t retval = glTranslatef; glTranslatef = f; return retval;}
-	virtual glActiveTexture_client_proc_t set_glActiveTexture(glActiveTexture_client_proc_t f) { glActiveTexture_client_proc_t retval = glActiveTexture; glActiveTexture = f; return retval;}
-	virtual glAlphaFuncx_client_proc_t set_glAlphaFuncx(glAlphaFuncx_client_proc_t f) { glAlphaFuncx_client_proc_t retval = glAlphaFuncx; glAlphaFuncx = f; return retval;}
-	virtual glBindBuffer_client_proc_t set_glBindBuffer(glBindBuffer_client_proc_t f) { glBindBuffer_client_proc_t retval = glBindBuffer; glBindBuffer = f; return retval;}
-	virtual glBindTexture_client_proc_t set_glBindTexture(glBindTexture_client_proc_t f) { glBindTexture_client_proc_t retval = glBindTexture; glBindTexture = f; return retval;}
-	virtual glBlendFunc_client_proc_t set_glBlendFunc(glBlendFunc_client_proc_t f) { glBlendFunc_client_proc_t retval = glBlendFunc; glBlendFunc = f; return retval;}
-	virtual glBufferData_client_proc_t set_glBufferData(glBufferData_client_proc_t f) { glBufferData_client_proc_t retval = glBufferData; glBufferData = f; return retval;}
-	virtual glBufferSubData_client_proc_t set_glBufferSubData(glBufferSubData_client_proc_t f) { glBufferSubData_client_proc_t retval = glBufferSubData; glBufferSubData = f; return retval;}
-	virtual glClear_client_proc_t set_glClear(glClear_client_proc_t f) { glClear_client_proc_t retval = glClear; glClear = f; return retval;}
-	virtual glClearColorx_client_proc_t set_glClearColorx(glClearColorx_client_proc_t f) { glClearColorx_client_proc_t retval = glClearColorx; glClearColorx = f; return retval;}
-	virtual glClearDepthx_client_proc_t set_glClearDepthx(glClearDepthx_client_proc_t f) { glClearDepthx_client_proc_t retval = glClearDepthx; glClearDepthx = f; return retval;}
-	virtual glClearStencil_client_proc_t set_glClearStencil(glClearStencil_client_proc_t f) { glClearStencil_client_proc_t retval = glClearStencil; glClearStencil = f; return retval;}
-	virtual glClientActiveTexture_client_proc_t set_glClientActiveTexture(glClientActiveTexture_client_proc_t f) { glClientActiveTexture_client_proc_t retval = glClientActiveTexture; glClientActiveTexture = f; return retval;}
-	virtual glColor4ub_client_proc_t set_glColor4ub(glColor4ub_client_proc_t f) { glColor4ub_client_proc_t retval = glColor4ub; glColor4ub = f; return retval;}
-	virtual glColor4x_client_proc_t set_glColor4x(glColor4x_client_proc_t f) { glColor4x_client_proc_t retval = glColor4x; glColor4x = f; return retval;}
-	virtual glColorMask_client_proc_t set_glColorMask(glColorMask_client_proc_t f) { glColorMask_client_proc_t retval = glColorMask; glColorMask = f; return retval;}
-	virtual glColorPointer_client_proc_t set_glColorPointer(glColorPointer_client_proc_t f) { glColorPointer_client_proc_t retval = glColorPointer; glColorPointer = f; return retval;}
-	virtual glCompressedTexImage2D_client_proc_t set_glCompressedTexImage2D(glCompressedTexImage2D_client_proc_t f) { glCompressedTexImage2D_client_proc_t retval = glCompressedTexImage2D; glCompressedTexImage2D = f; return retval;}
-	virtual glCompressedTexSubImage2D_client_proc_t set_glCompressedTexSubImage2D(glCompressedTexSubImage2D_client_proc_t f) { glCompressedTexSubImage2D_client_proc_t retval = glCompressedTexSubImage2D; glCompressedTexSubImage2D = f; return retval;}
-	virtual glCopyTexImage2D_client_proc_t set_glCopyTexImage2D(glCopyTexImage2D_client_proc_t f) { glCopyTexImage2D_client_proc_t retval = glCopyTexImage2D; glCopyTexImage2D = f; return retval;}
-	virtual glCopyTexSubImage2D_client_proc_t set_glCopyTexSubImage2D(glCopyTexSubImage2D_client_proc_t f) { glCopyTexSubImage2D_client_proc_t retval = glCopyTexSubImage2D; glCopyTexSubImage2D = f; return retval;}
-	virtual glCullFace_client_proc_t set_glCullFace(glCullFace_client_proc_t f) { glCullFace_client_proc_t retval = glCullFace; glCullFace = f; return retval;}
-	virtual glDeleteBuffers_client_proc_t set_glDeleteBuffers(glDeleteBuffers_client_proc_t f) { glDeleteBuffers_client_proc_t retval = glDeleteBuffers; glDeleteBuffers = f; return retval;}
-	virtual glDeleteTextures_client_proc_t set_glDeleteTextures(glDeleteTextures_client_proc_t f) { glDeleteTextures_client_proc_t retval = glDeleteTextures; glDeleteTextures = f; return retval;}
-	virtual glDepthFunc_client_proc_t set_glDepthFunc(glDepthFunc_client_proc_t f) { glDepthFunc_client_proc_t retval = glDepthFunc; glDepthFunc = f; return retval;}
-	virtual glDepthMask_client_proc_t set_glDepthMask(glDepthMask_client_proc_t f) { glDepthMask_client_proc_t retval = glDepthMask; glDepthMask = f; return retval;}
-	virtual glDepthRangex_client_proc_t set_glDepthRangex(glDepthRangex_client_proc_t f) { glDepthRangex_client_proc_t retval = glDepthRangex; glDepthRangex = f; return retval;}
-	virtual glDisable_client_proc_t set_glDisable(glDisable_client_proc_t f) { glDisable_client_proc_t retval = glDisable; glDisable = f; return retval;}
-	virtual glDisableClientState_client_proc_t set_glDisableClientState(glDisableClientState_client_proc_t f) { glDisableClientState_client_proc_t retval = glDisableClientState; glDisableClientState = f; return retval;}
-	virtual glDrawArrays_client_proc_t set_glDrawArrays(glDrawArrays_client_proc_t f) { glDrawArrays_client_proc_t retval = glDrawArrays; glDrawArrays = f; return retval;}
-	virtual glDrawElements_client_proc_t set_glDrawElements(glDrawElements_client_proc_t f) { glDrawElements_client_proc_t retval = glDrawElements; glDrawElements = f; return retval;}
-	virtual glEnable_client_proc_t set_glEnable(glEnable_client_proc_t f) { glEnable_client_proc_t retval = glEnable; glEnable = f; return retval;}
-	virtual glEnableClientState_client_proc_t set_glEnableClientState(glEnableClientState_client_proc_t f) { glEnableClientState_client_proc_t retval = glEnableClientState; glEnableClientState = f; return retval;}
-	virtual glFinish_client_proc_t set_glFinish(glFinish_client_proc_t f) { glFinish_client_proc_t retval = glFinish; glFinish = f; return retval;}
-	virtual glFlush_client_proc_t set_glFlush(glFlush_client_proc_t f) { glFlush_client_proc_t retval = glFlush; glFlush = f; return retval;}
-	virtual glFogx_client_proc_t set_glFogx(glFogx_client_proc_t f) { glFogx_client_proc_t retval = glFogx; glFogx = f; return retval;}
-	virtual glFogxv_client_proc_t set_glFogxv(glFogxv_client_proc_t f) { glFogxv_client_proc_t retval = glFogxv; glFogxv = f; return retval;}
-	virtual glFrontFace_client_proc_t set_glFrontFace(glFrontFace_client_proc_t f) { glFrontFace_client_proc_t retval = glFrontFace; glFrontFace = f; return retval;}
-	virtual glFrustumx_client_proc_t set_glFrustumx(glFrustumx_client_proc_t f) { glFrustumx_client_proc_t retval = glFrustumx; glFrustumx = f; return retval;}
-	virtual glGetBooleanv_client_proc_t set_glGetBooleanv(glGetBooleanv_client_proc_t f) { glGetBooleanv_client_proc_t retval = glGetBooleanv; glGetBooleanv = f; return retval;}
-	virtual glGetBufferParameteriv_client_proc_t set_glGetBufferParameteriv(glGetBufferParameteriv_client_proc_t f) { glGetBufferParameteriv_client_proc_t retval = glGetBufferParameteriv; glGetBufferParameteriv = f; return retval;}
-	virtual glClipPlanex_client_proc_t set_glClipPlanex(glClipPlanex_client_proc_t f) { glClipPlanex_client_proc_t retval = glClipPlanex; glClipPlanex = f; return retval;}
-	virtual glGenBuffers_client_proc_t set_glGenBuffers(glGenBuffers_client_proc_t f) { glGenBuffers_client_proc_t retval = glGenBuffers; glGenBuffers = f; return retval;}
-	virtual glGenTextures_client_proc_t set_glGenTextures(glGenTextures_client_proc_t f) { glGenTextures_client_proc_t retval = glGenTextures; glGenTextures = f; return retval;}
-	virtual glGetError_client_proc_t set_glGetError(glGetError_client_proc_t f) { glGetError_client_proc_t retval = glGetError; glGetError = f; return retval;}
-	virtual glGetFixedv_client_proc_t set_glGetFixedv(glGetFixedv_client_proc_t f) { glGetFixedv_client_proc_t retval = glGetFixedv; glGetFixedv = f; return retval;}
-	virtual glGetIntegerv_client_proc_t set_glGetIntegerv(glGetIntegerv_client_proc_t f) { glGetIntegerv_client_proc_t retval = glGetIntegerv; glGetIntegerv = f; return retval;}
-	virtual glGetLightxv_client_proc_t set_glGetLightxv(glGetLightxv_client_proc_t f) { glGetLightxv_client_proc_t retval = glGetLightxv; glGetLightxv = f; return retval;}
-	virtual glGetMaterialxv_client_proc_t set_glGetMaterialxv(glGetMaterialxv_client_proc_t f) { glGetMaterialxv_client_proc_t retval = glGetMaterialxv; glGetMaterialxv = f; return retval;}
-	virtual glGetPointerv_client_proc_t set_glGetPointerv(glGetPointerv_client_proc_t f) { glGetPointerv_client_proc_t retval = glGetPointerv; glGetPointerv = f; return retval;}
-	virtual glGetString_client_proc_t set_glGetString(glGetString_client_proc_t f) { glGetString_client_proc_t retval = glGetString; glGetString = f; return retval;}
-	virtual glGetTexEnviv_client_proc_t set_glGetTexEnviv(glGetTexEnviv_client_proc_t f) { glGetTexEnviv_client_proc_t retval = glGetTexEnviv; glGetTexEnviv = f; return retval;}
-	virtual glGetTexEnvxv_client_proc_t set_glGetTexEnvxv(glGetTexEnvxv_client_proc_t f) { glGetTexEnvxv_client_proc_t retval = glGetTexEnvxv; glGetTexEnvxv = f; return retval;}
-	virtual glGetTexParameteriv_client_proc_t set_glGetTexParameteriv(glGetTexParameteriv_client_proc_t f) { glGetTexParameteriv_client_proc_t retval = glGetTexParameteriv; glGetTexParameteriv = f; return retval;}
-	virtual glGetTexParameterxv_client_proc_t set_glGetTexParameterxv(glGetTexParameterxv_client_proc_t f) { glGetTexParameterxv_client_proc_t retval = glGetTexParameterxv; glGetTexParameterxv = f; return retval;}
-	virtual glHint_client_proc_t set_glHint(glHint_client_proc_t f) { glHint_client_proc_t retval = glHint; glHint = f; return retval;}
-	virtual glIsBuffer_client_proc_t set_glIsBuffer(glIsBuffer_client_proc_t f) { glIsBuffer_client_proc_t retval = glIsBuffer; glIsBuffer = f; return retval;}
-	virtual glIsEnabled_client_proc_t set_glIsEnabled(glIsEnabled_client_proc_t f) { glIsEnabled_client_proc_t retval = glIsEnabled; glIsEnabled = f; return retval;}
-	virtual glIsTexture_client_proc_t set_glIsTexture(glIsTexture_client_proc_t f) { glIsTexture_client_proc_t retval = glIsTexture; glIsTexture = f; return retval;}
-	virtual glLightModelx_client_proc_t set_glLightModelx(glLightModelx_client_proc_t f) { glLightModelx_client_proc_t retval = glLightModelx; glLightModelx = f; return retval;}
-	virtual glLightModelxv_client_proc_t set_glLightModelxv(glLightModelxv_client_proc_t f) { glLightModelxv_client_proc_t retval = glLightModelxv; glLightModelxv = f; return retval;}
-	virtual glLightx_client_proc_t set_glLightx(glLightx_client_proc_t f) { glLightx_client_proc_t retval = glLightx; glLightx = f; return retval;}
-	virtual glLightxv_client_proc_t set_glLightxv(glLightxv_client_proc_t f) { glLightxv_client_proc_t retval = glLightxv; glLightxv = f; return retval;}
-	virtual glLineWidthx_client_proc_t set_glLineWidthx(glLineWidthx_client_proc_t f) { glLineWidthx_client_proc_t retval = glLineWidthx; glLineWidthx = f; return retval;}
-	virtual glLoadIdentity_client_proc_t set_glLoadIdentity(glLoadIdentity_client_proc_t f) { glLoadIdentity_client_proc_t retval = glLoadIdentity; glLoadIdentity = f; return retval;}
-	virtual glLoadMatrixx_client_proc_t set_glLoadMatrixx(glLoadMatrixx_client_proc_t f) { glLoadMatrixx_client_proc_t retval = glLoadMatrixx; glLoadMatrixx = f; return retval;}
-	virtual glLogicOp_client_proc_t set_glLogicOp(glLogicOp_client_proc_t f) { glLogicOp_client_proc_t retval = glLogicOp; glLogicOp = f; return retval;}
-	virtual glMaterialx_client_proc_t set_glMaterialx(glMaterialx_client_proc_t f) { glMaterialx_client_proc_t retval = glMaterialx; glMaterialx = f; return retval;}
-	virtual glMaterialxv_client_proc_t set_glMaterialxv(glMaterialxv_client_proc_t f) { glMaterialxv_client_proc_t retval = glMaterialxv; glMaterialxv = f; return retval;}
-	virtual glMatrixMode_client_proc_t set_glMatrixMode(glMatrixMode_client_proc_t f) { glMatrixMode_client_proc_t retval = glMatrixMode; glMatrixMode = f; return retval;}
-	virtual glMultMatrixx_client_proc_t set_glMultMatrixx(glMultMatrixx_client_proc_t f) { glMultMatrixx_client_proc_t retval = glMultMatrixx; glMultMatrixx = f; return retval;}
-	virtual glMultiTexCoord4x_client_proc_t set_glMultiTexCoord4x(glMultiTexCoord4x_client_proc_t f) { glMultiTexCoord4x_client_proc_t retval = glMultiTexCoord4x; glMultiTexCoord4x = f; return retval;}
-	virtual glNormal3x_client_proc_t set_glNormal3x(glNormal3x_client_proc_t f) { glNormal3x_client_proc_t retval = glNormal3x; glNormal3x = f; return retval;}
-	virtual glNormalPointer_client_proc_t set_glNormalPointer(glNormalPointer_client_proc_t f) { glNormalPointer_client_proc_t retval = glNormalPointer; glNormalPointer = f; return retval;}
-	virtual glOrthox_client_proc_t set_glOrthox(glOrthox_client_proc_t f) { glOrthox_client_proc_t retval = glOrthox; glOrthox = f; return retval;}
-	virtual glPixelStorei_client_proc_t set_glPixelStorei(glPixelStorei_client_proc_t f) { glPixelStorei_client_proc_t retval = glPixelStorei; glPixelStorei = f; return retval;}
-	virtual glPointParameterx_client_proc_t set_glPointParameterx(glPointParameterx_client_proc_t f) { glPointParameterx_client_proc_t retval = glPointParameterx; glPointParameterx = f; return retval;}
-	virtual glPointParameterxv_client_proc_t set_glPointParameterxv(glPointParameterxv_client_proc_t f) { glPointParameterxv_client_proc_t retval = glPointParameterxv; glPointParameterxv = f; return retval;}
-	virtual glPointSizex_client_proc_t set_glPointSizex(glPointSizex_client_proc_t f) { glPointSizex_client_proc_t retval = glPointSizex; glPointSizex = f; return retval;}
-	virtual glPolygonOffsetx_client_proc_t set_glPolygonOffsetx(glPolygonOffsetx_client_proc_t f) { glPolygonOffsetx_client_proc_t retval = glPolygonOffsetx; glPolygonOffsetx = f; return retval;}
-	virtual glPopMatrix_client_proc_t set_glPopMatrix(glPopMatrix_client_proc_t f) { glPopMatrix_client_proc_t retval = glPopMatrix; glPopMatrix = f; return retval;}
-	virtual glPushMatrix_client_proc_t set_glPushMatrix(glPushMatrix_client_proc_t f) { glPushMatrix_client_proc_t retval = glPushMatrix; glPushMatrix = f; return retval;}
-	virtual glReadPixels_client_proc_t set_glReadPixels(glReadPixels_client_proc_t f) { glReadPixels_client_proc_t retval = glReadPixels; glReadPixels = f; return retval;}
-	virtual glRotatex_client_proc_t set_glRotatex(glRotatex_client_proc_t f) { glRotatex_client_proc_t retval = glRotatex; glRotatex = f; return retval;}
-	virtual glSampleCoverage_client_proc_t set_glSampleCoverage(glSampleCoverage_client_proc_t f) { glSampleCoverage_client_proc_t retval = glSampleCoverage; glSampleCoverage = f; return retval;}
-	virtual glSampleCoveragex_client_proc_t set_glSampleCoveragex(glSampleCoveragex_client_proc_t f) { glSampleCoveragex_client_proc_t retval = glSampleCoveragex; glSampleCoveragex = f; return retval;}
-	virtual glScalex_client_proc_t set_glScalex(glScalex_client_proc_t f) { glScalex_client_proc_t retval = glScalex; glScalex = f; return retval;}
-	virtual glScissor_client_proc_t set_glScissor(glScissor_client_proc_t f) { glScissor_client_proc_t retval = glScissor; glScissor = f; return retval;}
-	virtual glShadeModel_client_proc_t set_glShadeModel(glShadeModel_client_proc_t f) { glShadeModel_client_proc_t retval = glShadeModel; glShadeModel = f; return retval;}
-	virtual glStencilFunc_client_proc_t set_glStencilFunc(glStencilFunc_client_proc_t f) { glStencilFunc_client_proc_t retval = glStencilFunc; glStencilFunc = f; return retval;}
-	virtual glStencilMask_client_proc_t set_glStencilMask(glStencilMask_client_proc_t f) { glStencilMask_client_proc_t retval = glStencilMask; glStencilMask = f; return retval;}
-	virtual glStencilOp_client_proc_t set_glStencilOp(glStencilOp_client_proc_t f) { glStencilOp_client_proc_t retval = glStencilOp; glStencilOp = f; return retval;}
-	virtual glTexCoordPointer_client_proc_t set_glTexCoordPointer(glTexCoordPointer_client_proc_t f) { glTexCoordPointer_client_proc_t retval = glTexCoordPointer; glTexCoordPointer = f; return retval;}
-	virtual glTexEnvi_client_proc_t set_glTexEnvi(glTexEnvi_client_proc_t f) { glTexEnvi_client_proc_t retval = glTexEnvi; glTexEnvi = f; return retval;}
-	virtual glTexEnvx_client_proc_t set_glTexEnvx(glTexEnvx_client_proc_t f) { glTexEnvx_client_proc_t retval = glTexEnvx; glTexEnvx = f; return retval;}
-	virtual glTexEnviv_client_proc_t set_glTexEnviv(glTexEnviv_client_proc_t f) { glTexEnviv_client_proc_t retval = glTexEnviv; glTexEnviv = f; return retval;}
-	virtual glTexEnvxv_client_proc_t set_glTexEnvxv(glTexEnvxv_client_proc_t f) { glTexEnvxv_client_proc_t retval = glTexEnvxv; glTexEnvxv = f; return retval;}
-	virtual glTexImage2D_client_proc_t set_glTexImage2D(glTexImage2D_client_proc_t f) { glTexImage2D_client_proc_t retval = glTexImage2D; glTexImage2D = f; return retval;}
-	virtual glTexParameteri_client_proc_t set_glTexParameteri(glTexParameteri_client_proc_t f) { glTexParameteri_client_proc_t retval = glTexParameteri; glTexParameteri = f; return retval;}
-	virtual glTexParameterx_client_proc_t set_glTexParameterx(glTexParameterx_client_proc_t f) { glTexParameterx_client_proc_t retval = glTexParameterx; glTexParameterx = f; return retval;}
-	virtual glTexParameteriv_client_proc_t set_glTexParameteriv(glTexParameteriv_client_proc_t f) { glTexParameteriv_client_proc_t retval = glTexParameteriv; glTexParameteriv = f; return retval;}
-	virtual glTexParameterxv_client_proc_t set_glTexParameterxv(glTexParameterxv_client_proc_t f) { glTexParameterxv_client_proc_t retval = glTexParameterxv; glTexParameterxv = f; return retval;}
-	virtual glTexSubImage2D_client_proc_t set_glTexSubImage2D(glTexSubImage2D_client_proc_t f) { glTexSubImage2D_client_proc_t retval = glTexSubImage2D; glTexSubImage2D = f; return retval;}
-	virtual glTranslatex_client_proc_t set_glTranslatex(glTranslatex_client_proc_t f) { glTranslatex_client_proc_t retval = glTranslatex; glTranslatex = f; return retval;}
-	virtual glVertexPointer_client_proc_t set_glVertexPointer(glVertexPointer_client_proc_t f) { glVertexPointer_client_proc_t retval = glVertexPointer; glVertexPointer = f; return retval;}
-	virtual glViewport_client_proc_t set_glViewport(glViewport_client_proc_t f) { glViewport_client_proc_t retval = glViewport; glViewport = f; return retval;}
-	virtual glPointSizePointerOES_client_proc_t set_glPointSizePointerOES(glPointSizePointerOES_client_proc_t f) { glPointSizePointerOES_client_proc_t retval = glPointSizePointerOES; glPointSizePointerOES = f; return retval;}
-	virtual glVertexPointerOffset_client_proc_t set_glVertexPointerOffset(glVertexPointerOffset_client_proc_t f) { glVertexPointerOffset_client_proc_t retval = glVertexPointerOffset; glVertexPointerOffset = f; return retval;}
-	virtual glColorPointerOffset_client_proc_t set_glColorPointerOffset(glColorPointerOffset_client_proc_t f) { glColorPointerOffset_client_proc_t retval = glColorPointerOffset; glColorPointerOffset = f; return retval;}
-	virtual glNormalPointerOffset_client_proc_t set_glNormalPointerOffset(glNormalPointerOffset_client_proc_t f) { glNormalPointerOffset_client_proc_t retval = glNormalPointerOffset; glNormalPointerOffset = f; return retval;}
-	virtual glPointSizePointerOffset_client_proc_t set_glPointSizePointerOffset(glPointSizePointerOffset_client_proc_t f) { glPointSizePointerOffset_client_proc_t retval = glPointSizePointerOffset; glPointSizePointerOffset = f; return retval;}
-	virtual glTexCoordPointerOffset_client_proc_t set_glTexCoordPointerOffset(glTexCoordPointerOffset_client_proc_t f) { glTexCoordPointerOffset_client_proc_t retval = glTexCoordPointerOffset; glTexCoordPointerOffset = f; return retval;}
-	virtual glWeightPointerOffset_client_proc_t set_glWeightPointerOffset(glWeightPointerOffset_client_proc_t f) { glWeightPointerOffset_client_proc_t retval = glWeightPointerOffset; glWeightPointerOffset = f; return retval;}
-	virtual glMatrixIndexPointerOffset_client_proc_t set_glMatrixIndexPointerOffset(glMatrixIndexPointerOffset_client_proc_t f) { glMatrixIndexPointerOffset_client_proc_t retval = glMatrixIndexPointerOffset; glMatrixIndexPointerOffset = f; return retval;}
-	virtual glVertexPointerData_client_proc_t set_glVertexPointerData(glVertexPointerData_client_proc_t f) { glVertexPointerData_client_proc_t retval = glVertexPointerData; glVertexPointerData = f; return retval;}
-	virtual glColorPointerData_client_proc_t set_glColorPointerData(glColorPointerData_client_proc_t f) { glColorPointerData_client_proc_t retval = glColorPointerData; glColorPointerData = f; return retval;}
-	virtual glNormalPointerData_client_proc_t set_glNormalPointerData(glNormalPointerData_client_proc_t f) { glNormalPointerData_client_proc_t retval = glNormalPointerData; glNormalPointerData = f; return retval;}
-	virtual glTexCoordPointerData_client_proc_t set_glTexCoordPointerData(glTexCoordPointerData_client_proc_t f) { glTexCoordPointerData_client_proc_t retval = glTexCoordPointerData; glTexCoordPointerData = f; return retval;}
-	virtual glPointSizePointerData_client_proc_t set_glPointSizePointerData(glPointSizePointerData_client_proc_t f) { glPointSizePointerData_client_proc_t retval = glPointSizePointerData; glPointSizePointerData = f; return retval;}
-	virtual glWeightPointerData_client_proc_t set_glWeightPointerData(glWeightPointerData_client_proc_t f) { glWeightPointerData_client_proc_t retval = glWeightPointerData; glWeightPointerData = f; return retval;}
-	virtual glMatrixIndexPointerData_client_proc_t set_glMatrixIndexPointerData(glMatrixIndexPointerData_client_proc_t f) { glMatrixIndexPointerData_client_proc_t retval = glMatrixIndexPointerData; glMatrixIndexPointerData = f; return retval;}
-	virtual glDrawElementsOffset_client_proc_t set_glDrawElementsOffset(glDrawElementsOffset_client_proc_t f) { glDrawElementsOffset_client_proc_t retval = glDrawElementsOffset; glDrawElementsOffset = f; return retval;}
-	virtual glDrawElementsData_client_proc_t set_glDrawElementsData(glDrawElementsData_client_proc_t f) { glDrawElementsData_client_proc_t retval = glDrawElementsData; glDrawElementsData = f; return retval;}
-	virtual glGetCompressedTextureFormats_client_proc_t set_glGetCompressedTextureFormats(glGetCompressedTextureFormats_client_proc_t f) { glGetCompressedTextureFormats_client_proc_t retval = glGetCompressedTextureFormats; glGetCompressedTextureFormats = f; return retval;}
-	virtual glFinishRoundTrip_client_proc_t set_glFinishRoundTrip(glFinishRoundTrip_client_proc_t f) { glFinishRoundTrip_client_proc_t retval = glFinishRoundTrip; glFinishRoundTrip = f; return retval;}
-	virtual glBlendEquationSeparateOES_client_proc_t set_glBlendEquationSeparateOES(glBlendEquationSeparateOES_client_proc_t f) { glBlendEquationSeparateOES_client_proc_t retval = glBlendEquationSeparateOES; glBlendEquationSeparateOES = f; return retval;}
-	virtual glBlendFuncSeparateOES_client_proc_t set_glBlendFuncSeparateOES(glBlendFuncSeparateOES_client_proc_t f) { glBlendFuncSeparateOES_client_proc_t retval = glBlendFuncSeparateOES; glBlendFuncSeparateOES = f; return retval;}
-	virtual glBlendEquationOES_client_proc_t set_glBlendEquationOES(glBlendEquationOES_client_proc_t f) { glBlendEquationOES_client_proc_t retval = glBlendEquationOES; glBlendEquationOES = f; return retval;}
-	virtual glDrawTexsOES_client_proc_t set_glDrawTexsOES(glDrawTexsOES_client_proc_t f) { glDrawTexsOES_client_proc_t retval = glDrawTexsOES; glDrawTexsOES = f; return retval;}
-	virtual glDrawTexiOES_client_proc_t set_glDrawTexiOES(glDrawTexiOES_client_proc_t f) { glDrawTexiOES_client_proc_t retval = glDrawTexiOES; glDrawTexiOES = f; return retval;}
-	virtual glDrawTexxOES_client_proc_t set_glDrawTexxOES(glDrawTexxOES_client_proc_t f) { glDrawTexxOES_client_proc_t retval = glDrawTexxOES; glDrawTexxOES = f; return retval;}
-	virtual glDrawTexsvOES_client_proc_t set_glDrawTexsvOES(glDrawTexsvOES_client_proc_t f) { glDrawTexsvOES_client_proc_t retval = glDrawTexsvOES; glDrawTexsvOES = f; return retval;}
-	virtual glDrawTexivOES_client_proc_t set_glDrawTexivOES(glDrawTexivOES_client_proc_t f) { glDrawTexivOES_client_proc_t retval = glDrawTexivOES; glDrawTexivOES = f; return retval;}
-	virtual glDrawTexxvOES_client_proc_t set_glDrawTexxvOES(glDrawTexxvOES_client_proc_t f) { glDrawTexxvOES_client_proc_t retval = glDrawTexxvOES; glDrawTexxvOES = f; return retval;}
-	virtual glDrawTexfOES_client_proc_t set_glDrawTexfOES(glDrawTexfOES_client_proc_t f) { glDrawTexfOES_client_proc_t retval = glDrawTexfOES; glDrawTexfOES = f; return retval;}
-	virtual glDrawTexfvOES_client_proc_t set_glDrawTexfvOES(glDrawTexfvOES_client_proc_t f) { glDrawTexfvOES_client_proc_t retval = glDrawTexfvOES; glDrawTexfvOES = f; return retval;}
-	virtual glEGLImageTargetTexture2DOES_client_proc_t set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES_client_proc_t f) { glEGLImageTargetTexture2DOES_client_proc_t retval = glEGLImageTargetTexture2DOES; glEGLImageTargetTexture2DOES = f; return retval;}
-	virtual glEGLImageTargetRenderbufferStorageOES_client_proc_t set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES_client_proc_t f) { glEGLImageTargetRenderbufferStorageOES_client_proc_t retval = glEGLImageTargetRenderbufferStorageOES; glEGLImageTargetRenderbufferStorageOES = f; return retval;}
-	virtual glAlphaFuncxOES_client_proc_t set_glAlphaFuncxOES(glAlphaFuncxOES_client_proc_t f) { glAlphaFuncxOES_client_proc_t retval = glAlphaFuncxOES; glAlphaFuncxOES = f; return retval;}
-	virtual glClearColorxOES_client_proc_t set_glClearColorxOES(glClearColorxOES_client_proc_t f) { glClearColorxOES_client_proc_t retval = glClearColorxOES; glClearColorxOES = f; return retval;}
-	virtual glClearDepthxOES_client_proc_t set_glClearDepthxOES(glClearDepthxOES_client_proc_t f) { glClearDepthxOES_client_proc_t retval = glClearDepthxOES; glClearDepthxOES = f; return retval;}
-	virtual glClipPlanexOES_client_proc_t set_glClipPlanexOES(glClipPlanexOES_client_proc_t f) { glClipPlanexOES_client_proc_t retval = glClipPlanexOES; glClipPlanexOES = f; return retval;}
-	virtual glClipPlanexIMG_client_proc_t set_glClipPlanexIMG(glClipPlanexIMG_client_proc_t f) { glClipPlanexIMG_client_proc_t retval = glClipPlanexIMG; glClipPlanexIMG = f; return retval;}
-	virtual glColor4xOES_client_proc_t set_glColor4xOES(glColor4xOES_client_proc_t f) { glColor4xOES_client_proc_t retval = glColor4xOES; glColor4xOES = f; return retval;}
-	virtual glDepthRangexOES_client_proc_t set_glDepthRangexOES(glDepthRangexOES_client_proc_t f) { glDepthRangexOES_client_proc_t retval = glDepthRangexOES; glDepthRangexOES = f; return retval;}
-	virtual glFogxOES_client_proc_t set_glFogxOES(glFogxOES_client_proc_t f) { glFogxOES_client_proc_t retval = glFogxOES; glFogxOES = f; return retval;}
-	virtual glFogxvOES_client_proc_t set_glFogxvOES(glFogxvOES_client_proc_t f) { glFogxvOES_client_proc_t retval = glFogxvOES; glFogxvOES = f; return retval;}
-	virtual glFrustumxOES_client_proc_t set_glFrustumxOES(glFrustumxOES_client_proc_t f) { glFrustumxOES_client_proc_t retval = glFrustumxOES; glFrustumxOES = f; return retval;}
-	virtual glGetClipPlanexOES_client_proc_t set_glGetClipPlanexOES(glGetClipPlanexOES_client_proc_t f) { glGetClipPlanexOES_client_proc_t retval = glGetClipPlanexOES; glGetClipPlanexOES = f; return retval;}
-	virtual glGetClipPlanex_client_proc_t set_glGetClipPlanex(glGetClipPlanex_client_proc_t f) { glGetClipPlanex_client_proc_t retval = glGetClipPlanex; glGetClipPlanex = f; return retval;}
-	virtual glGetFixedvOES_client_proc_t set_glGetFixedvOES(glGetFixedvOES_client_proc_t f) { glGetFixedvOES_client_proc_t retval = glGetFixedvOES; glGetFixedvOES = f; return retval;}
-	virtual glGetLightxvOES_client_proc_t set_glGetLightxvOES(glGetLightxvOES_client_proc_t f) { glGetLightxvOES_client_proc_t retval = glGetLightxvOES; glGetLightxvOES = f; return retval;}
-	virtual glGetMaterialxvOES_client_proc_t set_glGetMaterialxvOES(glGetMaterialxvOES_client_proc_t f) { glGetMaterialxvOES_client_proc_t retval = glGetMaterialxvOES; glGetMaterialxvOES = f; return retval;}
-	virtual glGetTexEnvxvOES_client_proc_t set_glGetTexEnvxvOES(glGetTexEnvxvOES_client_proc_t f) { glGetTexEnvxvOES_client_proc_t retval = glGetTexEnvxvOES; glGetTexEnvxvOES = f; return retval;}
-	virtual glGetTexParameterxvOES_client_proc_t set_glGetTexParameterxvOES(glGetTexParameterxvOES_client_proc_t f) { glGetTexParameterxvOES_client_proc_t retval = glGetTexParameterxvOES; glGetTexParameterxvOES = f; return retval;}
-	virtual glLightModelxOES_client_proc_t set_glLightModelxOES(glLightModelxOES_client_proc_t f) { glLightModelxOES_client_proc_t retval = glLightModelxOES; glLightModelxOES = f; return retval;}
-	virtual glLightModelxvOES_client_proc_t set_glLightModelxvOES(glLightModelxvOES_client_proc_t f) { glLightModelxvOES_client_proc_t retval = glLightModelxvOES; glLightModelxvOES = f; return retval;}
-	virtual glLightxOES_client_proc_t set_glLightxOES(glLightxOES_client_proc_t f) { glLightxOES_client_proc_t retval = glLightxOES; glLightxOES = f; return retval;}
-	virtual glLightxvOES_client_proc_t set_glLightxvOES(glLightxvOES_client_proc_t f) { glLightxvOES_client_proc_t retval = glLightxvOES; glLightxvOES = f; return retval;}
-	virtual glLineWidthxOES_client_proc_t set_glLineWidthxOES(glLineWidthxOES_client_proc_t f) { glLineWidthxOES_client_proc_t retval = glLineWidthxOES; glLineWidthxOES = f; return retval;}
-	virtual glLoadMatrixxOES_client_proc_t set_glLoadMatrixxOES(glLoadMatrixxOES_client_proc_t f) { glLoadMatrixxOES_client_proc_t retval = glLoadMatrixxOES; glLoadMatrixxOES = f; return retval;}
-	virtual glMaterialxOES_client_proc_t set_glMaterialxOES(glMaterialxOES_client_proc_t f) { glMaterialxOES_client_proc_t retval = glMaterialxOES; glMaterialxOES = f; return retval;}
-	virtual glMaterialxvOES_client_proc_t set_glMaterialxvOES(glMaterialxvOES_client_proc_t f) { glMaterialxvOES_client_proc_t retval = glMaterialxvOES; glMaterialxvOES = f; return retval;}
-	virtual glMultMatrixxOES_client_proc_t set_glMultMatrixxOES(glMultMatrixxOES_client_proc_t f) { glMultMatrixxOES_client_proc_t retval = glMultMatrixxOES; glMultMatrixxOES = f; return retval;}
-	virtual glMultiTexCoord4xOES_client_proc_t set_glMultiTexCoord4xOES(glMultiTexCoord4xOES_client_proc_t f) { glMultiTexCoord4xOES_client_proc_t retval = glMultiTexCoord4xOES; glMultiTexCoord4xOES = f; return retval;}
-	virtual glNormal3xOES_client_proc_t set_glNormal3xOES(glNormal3xOES_client_proc_t f) { glNormal3xOES_client_proc_t retval = glNormal3xOES; glNormal3xOES = f; return retval;}
-	virtual glOrthoxOES_client_proc_t set_glOrthoxOES(glOrthoxOES_client_proc_t f) { glOrthoxOES_client_proc_t retval = glOrthoxOES; glOrthoxOES = f; return retval;}
-	virtual glPointParameterxOES_client_proc_t set_glPointParameterxOES(glPointParameterxOES_client_proc_t f) { glPointParameterxOES_client_proc_t retval = glPointParameterxOES; glPointParameterxOES = f; return retval;}
-	virtual glPointParameterxvOES_client_proc_t set_glPointParameterxvOES(glPointParameterxvOES_client_proc_t f) { glPointParameterxvOES_client_proc_t retval = glPointParameterxvOES; glPointParameterxvOES = f; return retval;}
-	virtual glPointSizexOES_client_proc_t set_glPointSizexOES(glPointSizexOES_client_proc_t f) { glPointSizexOES_client_proc_t retval = glPointSizexOES; glPointSizexOES = f; return retval;}
-	virtual glPolygonOffsetxOES_client_proc_t set_glPolygonOffsetxOES(glPolygonOffsetxOES_client_proc_t f) { glPolygonOffsetxOES_client_proc_t retval = glPolygonOffsetxOES; glPolygonOffsetxOES = f; return retval;}
-	virtual glRotatexOES_client_proc_t set_glRotatexOES(glRotatexOES_client_proc_t f) { glRotatexOES_client_proc_t retval = glRotatexOES; glRotatexOES = f; return retval;}
-	virtual glSampleCoveragexOES_client_proc_t set_glSampleCoveragexOES(glSampleCoveragexOES_client_proc_t f) { glSampleCoveragexOES_client_proc_t retval = glSampleCoveragexOES; glSampleCoveragexOES = f; return retval;}
-	virtual glScalexOES_client_proc_t set_glScalexOES(glScalexOES_client_proc_t f) { glScalexOES_client_proc_t retval = glScalexOES; glScalexOES = f; return retval;}
-	virtual glTexEnvxOES_client_proc_t set_glTexEnvxOES(glTexEnvxOES_client_proc_t f) { glTexEnvxOES_client_proc_t retval = glTexEnvxOES; glTexEnvxOES = f; return retval;}
-	virtual glTexEnvxvOES_client_proc_t set_glTexEnvxvOES(glTexEnvxvOES_client_proc_t f) { glTexEnvxvOES_client_proc_t retval = glTexEnvxvOES; glTexEnvxvOES = f; return retval;}
-	virtual glTexParameterxOES_client_proc_t set_glTexParameterxOES(glTexParameterxOES_client_proc_t f) { glTexParameterxOES_client_proc_t retval = glTexParameterxOES; glTexParameterxOES = f; return retval;}
-	virtual glTexParameterxvOES_client_proc_t set_glTexParameterxvOES(glTexParameterxvOES_client_proc_t f) { glTexParameterxvOES_client_proc_t retval = glTexParameterxvOES; glTexParameterxvOES = f; return retval;}
-	virtual glTranslatexOES_client_proc_t set_glTranslatexOES(glTranslatexOES_client_proc_t f) { glTranslatexOES_client_proc_t retval = glTranslatexOES; glTranslatexOES = f; return retval;}
-	virtual glIsRenderbufferOES_client_proc_t set_glIsRenderbufferOES(glIsRenderbufferOES_client_proc_t f) { glIsRenderbufferOES_client_proc_t retval = glIsRenderbufferOES; glIsRenderbufferOES = f; return retval;}
-	virtual glBindRenderbufferOES_client_proc_t set_glBindRenderbufferOES(glBindRenderbufferOES_client_proc_t f) { glBindRenderbufferOES_client_proc_t retval = glBindRenderbufferOES; glBindRenderbufferOES = f; return retval;}
-	virtual glDeleteRenderbuffersOES_client_proc_t set_glDeleteRenderbuffersOES(glDeleteRenderbuffersOES_client_proc_t f) { glDeleteRenderbuffersOES_client_proc_t retval = glDeleteRenderbuffersOES; glDeleteRenderbuffersOES = f; return retval;}
-	virtual glGenRenderbuffersOES_client_proc_t set_glGenRenderbuffersOES(glGenRenderbuffersOES_client_proc_t f) { glGenRenderbuffersOES_client_proc_t retval = glGenRenderbuffersOES; glGenRenderbuffersOES = f; return retval;}
-	virtual glRenderbufferStorageOES_client_proc_t set_glRenderbufferStorageOES(glRenderbufferStorageOES_client_proc_t f) { glRenderbufferStorageOES_client_proc_t retval = glRenderbufferStorageOES; glRenderbufferStorageOES = f; return retval;}
-	virtual glGetRenderbufferParameterivOES_client_proc_t set_glGetRenderbufferParameterivOES(glGetRenderbufferParameterivOES_client_proc_t f) { glGetRenderbufferParameterivOES_client_proc_t retval = glGetRenderbufferParameterivOES; glGetRenderbufferParameterivOES = f; return retval;}
-	virtual glIsFramebufferOES_client_proc_t set_glIsFramebufferOES(glIsFramebufferOES_client_proc_t f) { glIsFramebufferOES_client_proc_t retval = glIsFramebufferOES; glIsFramebufferOES = f; return retval;}
-	virtual glBindFramebufferOES_client_proc_t set_glBindFramebufferOES(glBindFramebufferOES_client_proc_t f) { glBindFramebufferOES_client_proc_t retval = glBindFramebufferOES; glBindFramebufferOES = f; return retval;}
-	virtual glDeleteFramebuffersOES_client_proc_t set_glDeleteFramebuffersOES(glDeleteFramebuffersOES_client_proc_t f) { glDeleteFramebuffersOES_client_proc_t retval = glDeleteFramebuffersOES; glDeleteFramebuffersOES = f; return retval;}
-	virtual glGenFramebuffersOES_client_proc_t set_glGenFramebuffersOES(glGenFramebuffersOES_client_proc_t f) { glGenFramebuffersOES_client_proc_t retval = glGenFramebuffersOES; glGenFramebuffersOES = f; return retval;}
-	virtual glCheckFramebufferStatusOES_client_proc_t set_glCheckFramebufferStatusOES(glCheckFramebufferStatusOES_client_proc_t f) { glCheckFramebufferStatusOES_client_proc_t retval = glCheckFramebufferStatusOES; glCheckFramebufferStatusOES = f; return retval;}
-	virtual glFramebufferRenderbufferOES_client_proc_t set_glFramebufferRenderbufferOES(glFramebufferRenderbufferOES_client_proc_t f) { glFramebufferRenderbufferOES_client_proc_t retval = glFramebufferRenderbufferOES; glFramebufferRenderbufferOES = f; return retval;}
-	virtual glFramebufferTexture2DOES_client_proc_t set_glFramebufferTexture2DOES(glFramebufferTexture2DOES_client_proc_t f) { glFramebufferTexture2DOES_client_proc_t retval = glFramebufferTexture2DOES; glFramebufferTexture2DOES = f; return retval;}
-	virtual glGetFramebufferAttachmentParameterivOES_client_proc_t set_glGetFramebufferAttachmentParameterivOES(glGetFramebufferAttachmentParameterivOES_client_proc_t f) { glGetFramebufferAttachmentParameterivOES_client_proc_t retval = glGetFramebufferAttachmentParameterivOES; glGetFramebufferAttachmentParameterivOES = f; return retval;}
-	virtual glGenerateMipmapOES_client_proc_t set_glGenerateMipmapOES(glGenerateMipmapOES_client_proc_t f) { glGenerateMipmapOES_client_proc_t retval = glGenerateMipmapOES; glGenerateMipmapOES = f; return retval;}
-	virtual glMapBufferOES_client_proc_t set_glMapBufferOES(glMapBufferOES_client_proc_t f) { glMapBufferOES_client_proc_t retval = glMapBufferOES; glMapBufferOES = f; return retval;}
-	virtual glUnmapBufferOES_client_proc_t set_glUnmapBufferOES(glUnmapBufferOES_client_proc_t f) { glUnmapBufferOES_client_proc_t retval = glUnmapBufferOES; glUnmapBufferOES = f; return retval;}
-	virtual glGetBufferPointervOES_client_proc_t set_glGetBufferPointervOES(glGetBufferPointervOES_client_proc_t f) { glGetBufferPointervOES_client_proc_t retval = glGetBufferPointervOES; glGetBufferPointervOES = f; return retval;}
-	virtual glCurrentPaletteMatrixOES_client_proc_t set_glCurrentPaletteMatrixOES(glCurrentPaletteMatrixOES_client_proc_t f) { glCurrentPaletteMatrixOES_client_proc_t retval = glCurrentPaletteMatrixOES; glCurrentPaletteMatrixOES = f; return retval;}
-	virtual glLoadPaletteFromModelViewMatrixOES_client_proc_t set_glLoadPaletteFromModelViewMatrixOES(glLoadPaletteFromModelViewMatrixOES_client_proc_t f) { glLoadPaletteFromModelViewMatrixOES_client_proc_t retval = glLoadPaletteFromModelViewMatrixOES; glLoadPaletteFromModelViewMatrixOES = f; return retval;}
-	virtual glMatrixIndexPointerOES_client_proc_t set_glMatrixIndexPointerOES(glMatrixIndexPointerOES_client_proc_t f) { glMatrixIndexPointerOES_client_proc_t retval = glMatrixIndexPointerOES; glMatrixIndexPointerOES = f; return retval;}
-	virtual glWeightPointerOES_client_proc_t set_glWeightPointerOES(glWeightPointerOES_client_proc_t f) { glWeightPointerOES_client_proc_t retval = glWeightPointerOES; glWeightPointerOES = f; return retval;}
-	virtual glQueryMatrixxOES_client_proc_t set_glQueryMatrixxOES(glQueryMatrixxOES_client_proc_t f) { glQueryMatrixxOES_client_proc_t retval = glQueryMatrixxOES; glQueryMatrixxOES = f; return retval;}
-	virtual glDepthRangefOES_client_proc_t set_glDepthRangefOES(glDepthRangefOES_client_proc_t f) { glDepthRangefOES_client_proc_t retval = glDepthRangefOES; glDepthRangefOES = f; return retval;}
-	virtual glFrustumfOES_client_proc_t set_glFrustumfOES(glFrustumfOES_client_proc_t f) { glFrustumfOES_client_proc_t retval = glFrustumfOES; glFrustumfOES = f; return retval;}
-	virtual glOrthofOES_client_proc_t set_glOrthofOES(glOrthofOES_client_proc_t f) { glOrthofOES_client_proc_t retval = glOrthofOES; glOrthofOES = f; return retval;}
-	virtual glClipPlanefOES_client_proc_t set_glClipPlanefOES(glClipPlanefOES_client_proc_t f) { glClipPlanefOES_client_proc_t retval = glClipPlanefOES; glClipPlanefOES = f; return retval;}
-	virtual glClipPlanefIMG_client_proc_t set_glClipPlanefIMG(glClipPlanefIMG_client_proc_t f) { glClipPlanefIMG_client_proc_t retval = glClipPlanefIMG; glClipPlanefIMG = f; return retval;}
-	virtual glGetClipPlanefOES_client_proc_t set_glGetClipPlanefOES(glGetClipPlanefOES_client_proc_t f) { glGetClipPlanefOES_client_proc_t retval = glGetClipPlanefOES; glGetClipPlanefOES = f; return retval;}
-	virtual glClearDepthfOES_client_proc_t set_glClearDepthfOES(glClearDepthfOES_client_proc_t f) { glClearDepthfOES_client_proc_t retval = glClearDepthfOES; glClearDepthfOES = f; return retval;}
-	virtual glTexGenfOES_client_proc_t set_glTexGenfOES(glTexGenfOES_client_proc_t f) { glTexGenfOES_client_proc_t retval = glTexGenfOES; glTexGenfOES = f; return retval;}
-	virtual glTexGenfvOES_client_proc_t set_glTexGenfvOES(glTexGenfvOES_client_proc_t f) { glTexGenfvOES_client_proc_t retval = glTexGenfvOES; glTexGenfvOES = f; return retval;}
-	virtual glTexGeniOES_client_proc_t set_glTexGeniOES(glTexGeniOES_client_proc_t f) { glTexGeniOES_client_proc_t retval = glTexGeniOES; glTexGeniOES = f; return retval;}
-	virtual glTexGenivOES_client_proc_t set_glTexGenivOES(glTexGenivOES_client_proc_t f) { glTexGenivOES_client_proc_t retval = glTexGenivOES; glTexGenivOES = f; return retval;}
-	virtual glTexGenxOES_client_proc_t set_glTexGenxOES(glTexGenxOES_client_proc_t f) { glTexGenxOES_client_proc_t retval = glTexGenxOES; glTexGenxOES = f; return retval;}
-	virtual glTexGenxvOES_client_proc_t set_glTexGenxvOES(glTexGenxvOES_client_proc_t f) { glTexGenxvOES_client_proc_t retval = glTexGenxvOES; glTexGenxvOES = f; return retval;}
-	virtual glGetTexGenfvOES_client_proc_t set_glGetTexGenfvOES(glGetTexGenfvOES_client_proc_t f) { glGetTexGenfvOES_client_proc_t retval = glGetTexGenfvOES; glGetTexGenfvOES = f; return retval;}
-	virtual glGetTexGenivOES_client_proc_t set_glGetTexGenivOES(glGetTexGenivOES_client_proc_t f) { glGetTexGenivOES_client_proc_t retval = glGetTexGenivOES; glGetTexGenivOES = f; return retval;}
-	virtual glGetTexGenxvOES_client_proc_t set_glGetTexGenxvOES(glGetTexGenxvOES_client_proc_t f) { glGetTexGenxvOES_client_proc_t retval = glGetTexGenxvOES; glGetTexGenxvOES = f; return retval;}
-	virtual glBindVertexArrayOES_client_proc_t set_glBindVertexArrayOES(glBindVertexArrayOES_client_proc_t f) { glBindVertexArrayOES_client_proc_t retval = glBindVertexArrayOES; glBindVertexArrayOES = f; return retval;}
-	virtual glDeleteVertexArraysOES_client_proc_t set_glDeleteVertexArraysOES(glDeleteVertexArraysOES_client_proc_t f) { glDeleteVertexArraysOES_client_proc_t retval = glDeleteVertexArraysOES; glDeleteVertexArraysOES = f; return retval;}
-	virtual glGenVertexArraysOES_client_proc_t set_glGenVertexArraysOES(glGenVertexArraysOES_client_proc_t f) { glGenVertexArraysOES_client_proc_t retval = glGenVertexArraysOES; glGenVertexArraysOES = f; return retval;}
-	virtual glIsVertexArrayOES_client_proc_t set_glIsVertexArrayOES(glIsVertexArrayOES_client_proc_t f) { glIsVertexArrayOES_client_proc_t retval = glIsVertexArrayOES; glIsVertexArrayOES = f; return retval;}
-	virtual glDiscardFramebufferEXT_client_proc_t set_glDiscardFramebufferEXT(glDiscardFramebufferEXT_client_proc_t f) { glDiscardFramebufferEXT_client_proc_t retval = glDiscardFramebufferEXT; glDiscardFramebufferEXT = f; return retval;}
-	virtual glMultiDrawArraysEXT_client_proc_t set_glMultiDrawArraysEXT(glMultiDrawArraysEXT_client_proc_t f) { glMultiDrawArraysEXT_client_proc_t retval = glMultiDrawArraysEXT; glMultiDrawArraysEXT = f; return retval;}
-	virtual glMultiDrawElementsEXT_client_proc_t set_glMultiDrawElementsEXT(glMultiDrawElementsEXT_client_proc_t f) { glMultiDrawElementsEXT_client_proc_t retval = glMultiDrawElementsEXT; glMultiDrawElementsEXT = f; return retval;}
-	virtual glMultiDrawArraysSUN_client_proc_t set_glMultiDrawArraysSUN(glMultiDrawArraysSUN_client_proc_t f) { glMultiDrawArraysSUN_client_proc_t retval = glMultiDrawArraysSUN; glMultiDrawArraysSUN = f; return retval;}
-	virtual glMultiDrawElementsSUN_client_proc_t set_glMultiDrawElementsSUN(glMultiDrawElementsSUN_client_proc_t f) { glMultiDrawElementsSUN_client_proc_t retval = glMultiDrawElementsSUN; glMultiDrawElementsSUN = f; return retval;}
-	virtual glRenderbufferStorageMultisampleIMG_client_proc_t set_glRenderbufferStorageMultisampleIMG(glRenderbufferStorageMultisampleIMG_client_proc_t f) { glRenderbufferStorageMultisampleIMG_client_proc_t retval = glRenderbufferStorageMultisampleIMG; glRenderbufferStorageMultisampleIMG = f; return retval;}
-	virtual glFramebufferTexture2DMultisampleIMG_client_proc_t set_glFramebufferTexture2DMultisampleIMG(glFramebufferTexture2DMultisampleIMG_client_proc_t f) { glFramebufferTexture2DMultisampleIMG_client_proc_t retval = glFramebufferTexture2DMultisampleIMG; glFramebufferTexture2DMultisampleIMG = f; return retval;}
-	virtual glDeleteFencesNV_client_proc_t set_glDeleteFencesNV(glDeleteFencesNV_client_proc_t f) { glDeleteFencesNV_client_proc_t retval = glDeleteFencesNV; glDeleteFencesNV = f; return retval;}
-	virtual glGenFencesNV_client_proc_t set_glGenFencesNV(glGenFencesNV_client_proc_t f) { glGenFencesNV_client_proc_t retval = glGenFencesNV; glGenFencesNV = f; return retval;}
-	virtual glIsFenceNV_client_proc_t set_glIsFenceNV(glIsFenceNV_client_proc_t f) { glIsFenceNV_client_proc_t retval = glIsFenceNV; glIsFenceNV = f; return retval;}
-	virtual glTestFenceNV_client_proc_t set_glTestFenceNV(glTestFenceNV_client_proc_t f) { glTestFenceNV_client_proc_t retval = glTestFenceNV; glTestFenceNV = f; return retval;}
-	virtual glGetFenceivNV_client_proc_t set_glGetFenceivNV(glGetFenceivNV_client_proc_t f) { glGetFenceivNV_client_proc_t retval = glGetFenceivNV; glGetFenceivNV = f; return retval;}
-	virtual glFinishFenceNV_client_proc_t set_glFinishFenceNV(glFinishFenceNV_client_proc_t f) { glFinishFenceNV_client_proc_t retval = glFinishFenceNV; glFinishFenceNV = f; return retval;}
-	virtual glSetFenceNV_client_proc_t set_glSetFenceNV(glSetFenceNV_client_proc_t f) { glSetFenceNV_client_proc_t retval = glSetFenceNV; glSetFenceNV = f; return retval;}
-	virtual glGetDriverControlsQCOM_client_proc_t set_glGetDriverControlsQCOM(glGetDriverControlsQCOM_client_proc_t f) { glGetDriverControlsQCOM_client_proc_t retval = glGetDriverControlsQCOM; glGetDriverControlsQCOM = f; return retval;}
-	virtual glGetDriverControlStringQCOM_client_proc_t set_glGetDriverControlStringQCOM(glGetDriverControlStringQCOM_client_proc_t f) { glGetDriverControlStringQCOM_client_proc_t retval = glGetDriverControlStringQCOM; glGetDriverControlStringQCOM = f; return retval;}
-	virtual glEnableDriverControlQCOM_client_proc_t set_glEnableDriverControlQCOM(glEnableDriverControlQCOM_client_proc_t f) { glEnableDriverControlQCOM_client_proc_t retval = glEnableDriverControlQCOM; glEnableDriverControlQCOM = f; return retval;}
-	virtual glDisableDriverControlQCOM_client_proc_t set_glDisableDriverControlQCOM(glDisableDriverControlQCOM_client_proc_t f) { glDisableDriverControlQCOM_client_proc_t retval = glDisableDriverControlQCOM; glDisableDriverControlQCOM = f; return retval;}
-	virtual glExtGetTexturesQCOM_client_proc_t set_glExtGetTexturesQCOM(glExtGetTexturesQCOM_client_proc_t f) { glExtGetTexturesQCOM_client_proc_t retval = glExtGetTexturesQCOM; glExtGetTexturesQCOM = f; return retval;}
-	virtual glExtGetBuffersQCOM_client_proc_t set_glExtGetBuffersQCOM(glExtGetBuffersQCOM_client_proc_t f) { glExtGetBuffersQCOM_client_proc_t retval = glExtGetBuffersQCOM; glExtGetBuffersQCOM = f; return retval;}
-	virtual glExtGetRenderbuffersQCOM_client_proc_t set_glExtGetRenderbuffersQCOM(glExtGetRenderbuffersQCOM_client_proc_t f) { glExtGetRenderbuffersQCOM_client_proc_t retval = glExtGetRenderbuffersQCOM; glExtGetRenderbuffersQCOM = f; return retval;}
-	virtual glExtGetFramebuffersQCOM_client_proc_t set_glExtGetFramebuffersQCOM(glExtGetFramebuffersQCOM_client_proc_t f) { glExtGetFramebuffersQCOM_client_proc_t retval = glExtGetFramebuffersQCOM; glExtGetFramebuffersQCOM = f; return retval;}
-	virtual glExtGetTexLevelParameterivQCOM_client_proc_t set_glExtGetTexLevelParameterivQCOM(glExtGetTexLevelParameterivQCOM_client_proc_t f) { glExtGetTexLevelParameterivQCOM_client_proc_t retval = glExtGetTexLevelParameterivQCOM; glExtGetTexLevelParameterivQCOM = f; return retval;}
-	virtual glExtTexObjectStateOverrideiQCOM_client_proc_t set_glExtTexObjectStateOverrideiQCOM(glExtTexObjectStateOverrideiQCOM_client_proc_t f) { glExtTexObjectStateOverrideiQCOM_client_proc_t retval = glExtTexObjectStateOverrideiQCOM; glExtTexObjectStateOverrideiQCOM = f; return retval;}
-	virtual glExtGetTexSubImageQCOM_client_proc_t set_glExtGetTexSubImageQCOM(glExtGetTexSubImageQCOM_client_proc_t f) { glExtGetTexSubImageQCOM_client_proc_t retval = glExtGetTexSubImageQCOM; glExtGetTexSubImageQCOM = f; return retval;}
-	virtual glExtGetBufferPointervQCOM_client_proc_t set_glExtGetBufferPointervQCOM(glExtGetBufferPointervQCOM_client_proc_t f) { glExtGetBufferPointervQCOM_client_proc_t retval = glExtGetBufferPointervQCOM; glExtGetBufferPointervQCOM = f; return retval;}
-	virtual glExtGetShadersQCOM_client_proc_t set_glExtGetShadersQCOM(glExtGetShadersQCOM_client_proc_t f) { glExtGetShadersQCOM_client_proc_t retval = glExtGetShadersQCOM; glExtGetShadersQCOM = f; return retval;}
-	virtual glExtGetProgramsQCOM_client_proc_t set_glExtGetProgramsQCOM(glExtGetProgramsQCOM_client_proc_t f) { glExtGetProgramsQCOM_client_proc_t retval = glExtGetProgramsQCOM; glExtGetProgramsQCOM = f; return retval;}
-	virtual glExtIsProgramBinaryQCOM_client_proc_t set_glExtIsProgramBinaryQCOM(glExtIsProgramBinaryQCOM_client_proc_t f) { glExtIsProgramBinaryQCOM_client_proc_t retval = glExtIsProgramBinaryQCOM; glExtIsProgramBinaryQCOM = f; return retval;}
-	virtual glExtGetProgramBinarySourceQCOM_client_proc_t set_glExtGetProgramBinarySourceQCOM(glExtGetProgramBinarySourceQCOM_client_proc_t f) { glExtGetProgramBinarySourceQCOM_client_proc_t retval = glExtGetProgramBinarySourceQCOM; glExtGetProgramBinarySourceQCOM = f; return retval;}
-	virtual glStartTilingQCOM_client_proc_t set_glStartTilingQCOM(glStartTilingQCOM_client_proc_t f) { glStartTilingQCOM_client_proc_t retval = glStartTilingQCOM; glStartTilingQCOM = f; return retval;}
-	virtual glEndTilingQCOM_client_proc_t set_glEndTilingQCOM(glEndTilingQCOM_client_proc_t f) { glEndTilingQCOM_client_proc_t retval = glEndTilingQCOM; glEndTilingQCOM = f; return retval;}
 	 virtual ~gl_client_context_t() {}
 
 	typedef gl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
 	static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f);
 	int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData);
-	virtual void setError(unsigned int  error){};
+	virtual void setError(unsigned int  error){ (void)error; };
 	virtual unsigned int getError(){ return 0; };
 };
 
diff --git a/opengl/system/GLESv1_enc/gl_enc.cpp b/opengl/system/GLESv1_enc/gl_enc.cpp
index 0a343df..61c0cee 100644
--- a/opengl/system/GLESv1_enc/gl_enc.cpp
+++ b/opengl/system/GLESv1_enc/gl_enc.cpp
@@ -9,7 +9,10 @@
 
 
 #include <stdio.h>
-static void enc_unsupported()
+
+namespace {
+
+void enc_unsupported()
 {
 	ALOGE("Function is unsupported\n");
 }
@@ -1206,7 +1209,7 @@ void glFinish_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glFinish;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1220,7 +1223,7 @@ void glFlush_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glFlush;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1394,7 +1397,7 @@ GLenum glGetError_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glGetError;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1720,7 +1723,7 @@ void glLoadIdentity_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glLoadIdentity;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1971,7 +1974,7 @@ void glPopMatrix_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glPopMatrix;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1985,7 +1988,7 @@ void glPushMatrix_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glPushMatrix;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1998,7 +2001,7 @@ void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei heig
 	gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels =  pixelDataSize(self, width, height, format, type, 1);
+	const unsigned int __size_pixels =  glesv1_enc::pixelDataSize(self, width, height, format, type, 1);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(packetSize);
@@ -2242,7 +2245,7 @@ void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalfor
 	gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels = ((pixels != NULL) ?  pixelDataSize(self, width, height, format, type, 0) : 0);
+	const unsigned int __size_pixels = ((pixels != NULL) ?  glesv1_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -2340,7 +2343,7 @@ void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset,
 	gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels =  pixelDataSize(self, width, height, format, type, 0);
+	const unsigned int __size_pixels =  glesv1_enc::pixelDataSize(self, width, height, format, type, 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -2729,7 +2732,7 @@ int glFinishRoundTrip_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glFinishRoundTrip;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -3995,7 +3998,7 @@ void glLoadPaletteFromModelViewMatrixOES_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glLoadPaletteFromModelViewMatrixOES;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -4769,7 +4772,7 @@ void glExtGetTexSubImageQCOM_enc(void *self , GLenum target, GLint level, GLint
 	gl_encoder_context_t *ctx = (gl_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_texels =  (depth * pixelDataSize(self, width, height, format, type, 0));
+	const unsigned int __size_texels =  (depth * glesv1_enc::pixelDataSize(self, width, height, format, type, 0));
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_texels + 1*4;
 	ptr = stream->alloc(packetSize);
@@ -4885,300 +4888,302 @@ void glEndTilingQCOM_enc(void *self , GLbitfield preserveMask)
 		memcpy(ptr, &preserveMask, 4); ptr += 4;
 }
 
+}  // namespace
+
 gl_encoder_context_t::gl_encoder_context_t(IOStream *stream)
 {
 	m_stream = stream;
 
-	set_glAlphaFunc(glAlphaFunc_enc);
-	set_glClearColor(glClearColor_enc);
-	set_glClearDepthf(glClearDepthf_enc);
-	set_glClipPlanef(glClipPlanef_enc);
-	set_glColor4f(glColor4f_enc);
-	set_glDepthRangef(glDepthRangef_enc);
-	set_glFogf(glFogf_enc);
-	set_glFogfv(glFogfv_enc);
-	set_glFrustumf(glFrustumf_enc);
-	set_glGetClipPlanef(glGetClipPlanef_enc);
-	set_glGetFloatv(glGetFloatv_enc);
-	set_glGetLightfv(glGetLightfv_enc);
-	set_glGetMaterialfv(glGetMaterialfv_enc);
-	set_glGetTexEnvfv(glGetTexEnvfv_enc);
-	set_glGetTexParameterfv(glGetTexParameterfv_enc);
-	set_glLightModelf(glLightModelf_enc);
-	set_glLightModelfv(glLightModelfv_enc);
-	set_glLightf(glLightf_enc);
-	set_glLightfv(glLightfv_enc);
-	set_glLineWidth(glLineWidth_enc);
-	set_glLoadMatrixf(glLoadMatrixf_enc);
-	set_glMaterialf(glMaterialf_enc);
-	set_glMaterialfv(glMaterialfv_enc);
-	set_glMultMatrixf(glMultMatrixf_enc);
-	set_glMultiTexCoord4f(glMultiTexCoord4f_enc);
-	set_glNormal3f(glNormal3f_enc);
-	set_glOrthof(glOrthof_enc);
-	set_glPointParameterf(glPointParameterf_enc);
-	set_glPointParameterfv(glPointParameterfv_enc);
-	set_glPointSize(glPointSize_enc);
-	set_glPolygonOffset(glPolygonOffset_enc);
-	set_glRotatef(glRotatef_enc);
-	set_glScalef(glScalef_enc);
-	set_glTexEnvf(glTexEnvf_enc);
-	set_glTexEnvfv(glTexEnvfv_enc);
-	set_glTexParameterf(glTexParameterf_enc);
-	set_glTexParameterfv(glTexParameterfv_enc);
-	set_glTranslatef(glTranslatef_enc);
-	set_glActiveTexture(glActiveTexture_enc);
-	set_glAlphaFuncx(glAlphaFuncx_enc);
-	set_glBindBuffer(glBindBuffer_enc);
-	set_glBindTexture(glBindTexture_enc);
-	set_glBlendFunc(glBlendFunc_enc);
-	set_glBufferData(glBufferData_enc);
-	set_glBufferSubData(glBufferSubData_enc);
-	set_glClear(glClear_enc);
-	set_glClearColorx(glClearColorx_enc);
-	set_glClearDepthx(glClearDepthx_enc);
-	set_glClearStencil(glClearStencil_enc);
-	set_glClientActiveTexture(glClientActiveTexture_enc);
-	set_glColor4ub(glColor4ub_enc);
-	set_glColor4x(glColor4x_enc);
-	set_glColorMask(glColorMask_enc);
-	set_glColorPointer((glColorPointer_client_proc_t)(enc_unsupported));
-	set_glCompressedTexImage2D(glCompressedTexImage2D_enc);
-	set_glCompressedTexSubImage2D(glCompressedTexSubImage2D_enc);
-	set_glCopyTexImage2D(glCopyTexImage2D_enc);
-	set_glCopyTexSubImage2D(glCopyTexSubImage2D_enc);
-	set_glCullFace(glCullFace_enc);
-	set_glDeleteBuffers(glDeleteBuffers_enc);
-	set_glDeleteTextures(glDeleteTextures_enc);
-	set_glDepthFunc(glDepthFunc_enc);
-	set_glDepthMask(glDepthMask_enc);
-	set_glDepthRangex(glDepthRangex_enc);
-	set_glDisable(glDisable_enc);
-	set_glDisableClientState(glDisableClientState_enc);
-	set_glDrawArrays(glDrawArrays_enc);
-	set_glDrawElements((glDrawElements_client_proc_t)(enc_unsupported));
-	set_glEnable(glEnable_enc);
-	set_glEnableClientState(glEnableClientState_enc);
-	set_glFinish(glFinish_enc);
-	set_glFlush(glFlush_enc);
-	set_glFogx(glFogx_enc);
-	set_glFogxv(glFogxv_enc);
-	set_glFrontFace(glFrontFace_enc);
-	set_glFrustumx(glFrustumx_enc);
-	set_glGetBooleanv(glGetBooleanv_enc);
-	set_glGetBufferParameteriv(glGetBufferParameteriv_enc);
-	set_glClipPlanex(glClipPlanex_enc);
-	set_glGenBuffers(glGenBuffers_enc);
-	set_glGenTextures(glGenTextures_enc);
-	set_glGetError(glGetError_enc);
-	set_glGetFixedv(glGetFixedv_enc);
-	set_glGetIntegerv(glGetIntegerv_enc);
-	set_glGetLightxv(glGetLightxv_enc);
-	set_glGetMaterialxv(glGetMaterialxv_enc);
-	set_glGetPointerv((glGetPointerv_client_proc_t)(enc_unsupported));
-	set_glGetString((glGetString_client_proc_t)(enc_unsupported));
-	set_glGetTexEnviv(glGetTexEnviv_enc);
-	set_glGetTexEnvxv(glGetTexEnvxv_enc);
-	set_glGetTexParameteriv(glGetTexParameteriv_enc);
-	set_glGetTexParameterxv(glGetTexParameterxv_enc);
-	set_glHint(glHint_enc);
-	set_glIsBuffer(glIsBuffer_enc);
-	set_glIsEnabled(glIsEnabled_enc);
-	set_glIsTexture(glIsTexture_enc);
-	set_glLightModelx(glLightModelx_enc);
-	set_glLightModelxv(glLightModelxv_enc);
-	set_glLightx(glLightx_enc);
-	set_glLightxv(glLightxv_enc);
-	set_glLineWidthx(glLineWidthx_enc);
-	set_glLoadIdentity(glLoadIdentity_enc);
-	set_glLoadMatrixx(glLoadMatrixx_enc);
-	set_glLogicOp(glLogicOp_enc);
-	set_glMaterialx(glMaterialx_enc);
-	set_glMaterialxv(glMaterialxv_enc);
-	set_glMatrixMode(glMatrixMode_enc);
-	set_glMultMatrixx(glMultMatrixx_enc);
-	set_glMultiTexCoord4x(glMultiTexCoord4x_enc);
-	set_glNormal3x(glNormal3x_enc);
-	set_glNormalPointer((glNormalPointer_client_proc_t)(enc_unsupported));
-	set_glOrthox(glOrthox_enc);
-	set_glPixelStorei(glPixelStorei_enc);
-	set_glPointParameterx(glPointParameterx_enc);
-	set_glPointParameterxv(glPointParameterxv_enc);
-	set_glPointSizex(glPointSizex_enc);
-	set_glPolygonOffsetx(glPolygonOffsetx_enc);
-	set_glPopMatrix(glPopMatrix_enc);
-	set_glPushMatrix(glPushMatrix_enc);
-	set_glReadPixels(glReadPixels_enc);
-	set_glRotatex(glRotatex_enc);
-	set_glSampleCoverage(glSampleCoverage_enc);
-	set_glSampleCoveragex(glSampleCoveragex_enc);
-	set_glScalex(glScalex_enc);
-	set_glScissor(glScissor_enc);
-	set_glShadeModel(glShadeModel_enc);
-	set_glStencilFunc(glStencilFunc_enc);
-	set_glStencilMask(glStencilMask_enc);
-	set_glStencilOp(glStencilOp_enc);
-	set_glTexCoordPointer((glTexCoordPointer_client_proc_t)(enc_unsupported));
-	set_glTexEnvi(glTexEnvi_enc);
-	set_glTexEnvx(glTexEnvx_enc);
-	set_glTexEnviv(glTexEnviv_enc);
-	set_glTexEnvxv(glTexEnvxv_enc);
-	set_glTexImage2D(glTexImage2D_enc);
-	set_glTexParameteri(glTexParameteri_enc);
-	set_glTexParameterx(glTexParameterx_enc);
-	set_glTexParameteriv(glTexParameteriv_enc);
-	set_glTexParameterxv(glTexParameterxv_enc);
-	set_glTexSubImage2D(glTexSubImage2D_enc);
-	set_glTranslatex(glTranslatex_enc);
-	set_glVertexPointer((glVertexPointer_client_proc_t)(enc_unsupported));
-	set_glViewport(glViewport_enc);
-	set_glPointSizePointerOES((glPointSizePointerOES_client_proc_t)(enc_unsupported));
-	set_glVertexPointerOffset(glVertexPointerOffset_enc);
-	set_glColorPointerOffset(glColorPointerOffset_enc);
-	set_glNormalPointerOffset(glNormalPointerOffset_enc);
-	set_glPointSizePointerOffset(glPointSizePointerOffset_enc);
-	set_glTexCoordPointerOffset(glTexCoordPointerOffset_enc);
-	set_glWeightPointerOffset(glWeightPointerOffset_enc);
-	set_glMatrixIndexPointerOffset(glMatrixIndexPointerOffset_enc);
-	set_glVertexPointerData(glVertexPointerData_enc);
-	set_glColorPointerData(glColorPointerData_enc);
-	set_glNormalPointerData(glNormalPointerData_enc);
-	set_glTexCoordPointerData(glTexCoordPointerData_enc);
-	set_glPointSizePointerData(glPointSizePointerData_enc);
-	set_glWeightPointerData(glWeightPointerData_enc);
-	set_glMatrixIndexPointerData(glMatrixIndexPointerData_enc);
-	set_glDrawElementsOffset(glDrawElementsOffset_enc);
-	set_glDrawElementsData(glDrawElementsData_enc);
-	set_glGetCompressedTextureFormats(glGetCompressedTextureFormats_enc);
-	set_glFinishRoundTrip(glFinishRoundTrip_enc);
-	set_glBlendEquationSeparateOES(glBlendEquationSeparateOES_enc);
-	set_glBlendFuncSeparateOES(glBlendFuncSeparateOES_enc);
-	set_glBlendEquationOES(glBlendEquationOES_enc);
-	set_glDrawTexsOES(glDrawTexsOES_enc);
-	set_glDrawTexiOES(glDrawTexiOES_enc);
-	set_glDrawTexxOES(glDrawTexxOES_enc);
-	set_glDrawTexsvOES(glDrawTexsvOES_enc);
-	set_glDrawTexivOES(glDrawTexivOES_enc);
-	set_glDrawTexxvOES(glDrawTexxvOES_enc);
-	set_glDrawTexfOES(glDrawTexfOES_enc);
-	set_glDrawTexfvOES(glDrawTexfvOES_enc);
-	set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES_enc);
-	set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES_enc);
-	set_glAlphaFuncxOES(glAlphaFuncxOES_enc);
-	set_glClearColorxOES(glClearColorxOES_enc);
-	set_glClearDepthxOES(glClearDepthxOES_enc);
-	set_glClipPlanexOES(glClipPlanexOES_enc);
-	set_glClipPlanexIMG(glClipPlanexIMG_enc);
-	set_glColor4xOES(glColor4xOES_enc);
-	set_glDepthRangexOES(glDepthRangexOES_enc);
-	set_glFogxOES(glFogxOES_enc);
-	set_glFogxvOES(glFogxvOES_enc);
-	set_glFrustumxOES(glFrustumxOES_enc);
-	set_glGetClipPlanexOES(glGetClipPlanexOES_enc);
-	set_glGetClipPlanex(glGetClipPlanex_enc);
-	set_glGetFixedvOES(glGetFixedvOES_enc);
-	set_glGetLightxvOES(glGetLightxvOES_enc);
-	set_glGetMaterialxvOES(glGetMaterialxvOES_enc);
-	set_glGetTexEnvxvOES(glGetTexEnvxvOES_enc);
-	set_glGetTexParameterxvOES(glGetTexParameterxvOES_enc);
-	set_glLightModelxOES(glLightModelxOES_enc);
-	set_glLightModelxvOES(glLightModelxvOES_enc);
-	set_glLightxOES(glLightxOES_enc);
-	set_glLightxvOES(glLightxvOES_enc);
-	set_glLineWidthxOES(glLineWidthxOES_enc);
-	set_glLoadMatrixxOES(glLoadMatrixxOES_enc);
-	set_glMaterialxOES(glMaterialxOES_enc);
-	set_glMaterialxvOES(glMaterialxvOES_enc);
-	set_glMultMatrixxOES(glMultMatrixxOES_enc);
-	set_glMultiTexCoord4xOES(glMultiTexCoord4xOES_enc);
-	set_glNormal3xOES(glNormal3xOES_enc);
-	set_glOrthoxOES(glOrthoxOES_enc);
-	set_glPointParameterxOES(glPointParameterxOES_enc);
-	set_glPointParameterxvOES(glPointParameterxvOES_enc);
-	set_glPointSizexOES(glPointSizexOES_enc);
-	set_glPolygonOffsetxOES(glPolygonOffsetxOES_enc);
-	set_glRotatexOES(glRotatexOES_enc);
-	set_glSampleCoveragexOES(glSampleCoveragexOES_enc);
-	set_glScalexOES(glScalexOES_enc);
-	set_glTexEnvxOES(glTexEnvxOES_enc);
-	set_glTexEnvxvOES(glTexEnvxvOES_enc);
-	set_glTexParameterxOES(glTexParameterxOES_enc);
-	set_glTexParameterxvOES(glTexParameterxvOES_enc);
-	set_glTranslatexOES(glTranslatexOES_enc);
-	set_glIsRenderbufferOES(glIsRenderbufferOES_enc);
-	set_glBindRenderbufferOES(glBindRenderbufferOES_enc);
-	set_glDeleteRenderbuffersOES(glDeleteRenderbuffersOES_enc);
-	set_glGenRenderbuffersOES(glGenRenderbuffersOES_enc);
-	set_glRenderbufferStorageOES(glRenderbufferStorageOES_enc);
-	set_glGetRenderbufferParameterivOES(glGetRenderbufferParameterivOES_enc);
-	set_glIsFramebufferOES(glIsFramebufferOES_enc);
-	set_glBindFramebufferOES(glBindFramebufferOES_enc);
-	set_glDeleteFramebuffersOES(glDeleteFramebuffersOES_enc);
-	set_glGenFramebuffersOES(glGenFramebuffersOES_enc);
-	set_glCheckFramebufferStatusOES(glCheckFramebufferStatusOES_enc);
-	set_glFramebufferRenderbufferOES(glFramebufferRenderbufferOES_enc);
-	set_glFramebufferTexture2DOES(glFramebufferTexture2DOES_enc);
-	set_glGetFramebufferAttachmentParameterivOES(glGetFramebufferAttachmentParameterivOES_enc);
-	set_glGenerateMipmapOES(glGenerateMipmapOES_enc);
-	set_glMapBufferOES((glMapBufferOES_client_proc_t)(enc_unsupported));
-	set_glUnmapBufferOES(glUnmapBufferOES_enc);
-	set_glGetBufferPointervOES((glGetBufferPointervOES_client_proc_t)(enc_unsupported));
-	set_glCurrentPaletteMatrixOES(glCurrentPaletteMatrixOES_enc);
-	set_glLoadPaletteFromModelViewMatrixOES(glLoadPaletteFromModelViewMatrixOES_enc);
-	set_glMatrixIndexPointerOES((glMatrixIndexPointerOES_client_proc_t)(enc_unsupported));
-	set_glWeightPointerOES((glWeightPointerOES_client_proc_t)(enc_unsupported));
-	set_glQueryMatrixxOES(glQueryMatrixxOES_enc);
-	set_glDepthRangefOES(glDepthRangefOES_enc);
-	set_glFrustumfOES(glFrustumfOES_enc);
-	set_glOrthofOES(glOrthofOES_enc);
-	set_glClipPlanefOES(glClipPlanefOES_enc);
-	set_glClipPlanefIMG(glClipPlanefIMG_enc);
-	set_glGetClipPlanefOES(glGetClipPlanefOES_enc);
-	set_glClearDepthfOES(glClearDepthfOES_enc);
-	set_glTexGenfOES(glTexGenfOES_enc);
-	set_glTexGenfvOES(glTexGenfvOES_enc);
-	set_glTexGeniOES(glTexGeniOES_enc);
-	set_glTexGenivOES(glTexGenivOES_enc);
-	set_glTexGenxOES(glTexGenxOES_enc);
-	set_glTexGenxvOES(glTexGenxvOES_enc);
-	set_glGetTexGenfvOES(glGetTexGenfvOES_enc);
-	set_glGetTexGenivOES(glGetTexGenivOES_enc);
-	set_glGetTexGenxvOES(glGetTexGenxvOES_enc);
-	set_glBindVertexArrayOES(glBindVertexArrayOES_enc);
-	set_glDeleteVertexArraysOES(glDeleteVertexArraysOES_enc);
-	set_glGenVertexArraysOES(glGenVertexArraysOES_enc);
-	set_glIsVertexArrayOES(glIsVertexArrayOES_enc);
-	set_glDiscardFramebufferEXT(glDiscardFramebufferEXT_enc);
-	set_glMultiDrawArraysEXT((glMultiDrawArraysEXT_client_proc_t)(enc_unsupported));
-	set_glMultiDrawElementsEXT((glMultiDrawElementsEXT_client_proc_t)(enc_unsupported));
-	set_glMultiDrawArraysSUN((glMultiDrawArraysSUN_client_proc_t)(enc_unsupported));
-	set_glMultiDrawElementsSUN((glMultiDrawElementsSUN_client_proc_t)(enc_unsupported));
-	set_glRenderbufferStorageMultisampleIMG(glRenderbufferStorageMultisampleIMG_enc);
-	set_glFramebufferTexture2DMultisampleIMG(glFramebufferTexture2DMultisampleIMG_enc);
-	set_glDeleteFencesNV(glDeleteFencesNV_enc);
-	set_glGenFencesNV(glGenFencesNV_enc);
-	set_glIsFenceNV(glIsFenceNV_enc);
-	set_glTestFenceNV(glTestFenceNV_enc);
-	set_glGetFenceivNV(glGetFenceivNV_enc);
-	set_glFinishFenceNV(glFinishFenceNV_enc);
-	set_glSetFenceNV(glSetFenceNV_enc);
-	set_glGetDriverControlsQCOM(glGetDriverControlsQCOM_enc);
-	set_glGetDriverControlStringQCOM(glGetDriverControlStringQCOM_enc);
-	set_glEnableDriverControlQCOM(glEnableDriverControlQCOM_enc);
-	set_glDisableDriverControlQCOM(glDisableDriverControlQCOM_enc);
-	set_glExtGetTexturesQCOM(glExtGetTexturesQCOM_enc);
-	set_glExtGetBuffersQCOM(glExtGetBuffersQCOM_enc);
-	set_glExtGetRenderbuffersQCOM(glExtGetRenderbuffersQCOM_enc);
-	set_glExtGetFramebuffersQCOM(glExtGetFramebuffersQCOM_enc);
-	set_glExtGetTexLevelParameterivQCOM(glExtGetTexLevelParameterivQCOM_enc);
-	set_glExtTexObjectStateOverrideiQCOM(glExtTexObjectStateOverrideiQCOM_enc);
-	set_glExtGetTexSubImageQCOM(glExtGetTexSubImageQCOM_enc);
-	set_glExtGetBufferPointervQCOM((glExtGetBufferPointervQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetShadersQCOM(glExtGetShadersQCOM_enc);
-	set_glExtGetProgramsQCOM(glExtGetProgramsQCOM_enc);
-	set_glExtIsProgramBinaryQCOM(glExtIsProgramBinaryQCOM_enc);
-	set_glExtGetProgramBinarySourceQCOM((glExtGetProgramBinarySourceQCOM_client_proc_t)(enc_unsupported));
-	set_glStartTilingQCOM(glStartTilingQCOM_enc);
-	set_glEndTilingQCOM(glEndTilingQCOM_enc);
+	this->glAlphaFunc = &glAlphaFunc_enc;
+	this->glClearColor = &glClearColor_enc;
+	this->glClearDepthf = &glClearDepthf_enc;
+	this->glClipPlanef = &glClipPlanef_enc;
+	this->glColor4f = &glColor4f_enc;
+	this->glDepthRangef = &glDepthRangef_enc;
+	this->glFogf = &glFogf_enc;
+	this->glFogfv = &glFogfv_enc;
+	this->glFrustumf = &glFrustumf_enc;
+	this->glGetClipPlanef = &glGetClipPlanef_enc;
+	this->glGetFloatv = &glGetFloatv_enc;
+	this->glGetLightfv = &glGetLightfv_enc;
+	this->glGetMaterialfv = &glGetMaterialfv_enc;
+	this->glGetTexEnvfv = &glGetTexEnvfv_enc;
+	this->glGetTexParameterfv = &glGetTexParameterfv_enc;
+	this->glLightModelf = &glLightModelf_enc;
+	this->glLightModelfv = &glLightModelfv_enc;
+	this->glLightf = &glLightf_enc;
+	this->glLightfv = &glLightfv_enc;
+	this->glLineWidth = &glLineWidth_enc;
+	this->glLoadMatrixf = &glLoadMatrixf_enc;
+	this->glMaterialf = &glMaterialf_enc;
+	this->glMaterialfv = &glMaterialfv_enc;
+	this->glMultMatrixf = &glMultMatrixf_enc;
+	this->glMultiTexCoord4f = &glMultiTexCoord4f_enc;
+	this->glNormal3f = &glNormal3f_enc;
+	this->glOrthof = &glOrthof_enc;
+	this->glPointParameterf = &glPointParameterf_enc;
+	this->glPointParameterfv = &glPointParameterfv_enc;
+	this->glPointSize = &glPointSize_enc;
+	this->glPolygonOffset = &glPolygonOffset_enc;
+	this->glRotatef = &glRotatef_enc;
+	this->glScalef = &glScalef_enc;
+	this->glTexEnvf = &glTexEnvf_enc;
+	this->glTexEnvfv = &glTexEnvfv_enc;
+	this->glTexParameterf = &glTexParameterf_enc;
+	this->glTexParameterfv = &glTexParameterfv_enc;
+	this->glTranslatef = &glTranslatef_enc;
+	this->glActiveTexture = &glActiveTexture_enc;
+	this->glAlphaFuncx = &glAlphaFuncx_enc;
+	this->glBindBuffer = &glBindBuffer_enc;
+	this->glBindTexture = &glBindTexture_enc;
+	this->glBlendFunc = &glBlendFunc_enc;
+	this->glBufferData = &glBufferData_enc;
+	this->glBufferSubData = &glBufferSubData_enc;
+	this->glClear = &glClear_enc;
+	this->glClearColorx = &glClearColorx_enc;
+	this->glClearDepthx = &glClearDepthx_enc;
+	this->glClearStencil = &glClearStencil_enc;
+	this->glClientActiveTexture = &glClientActiveTexture_enc;
+	this->glColor4ub = &glColor4ub_enc;
+	this->glColor4x = &glColor4x_enc;
+	this->glColorMask = &glColorMask_enc;
+	this->glColorPointer = (glColorPointer_client_proc_t) &enc_unsupported;
+	this->glCompressedTexImage2D = &glCompressedTexImage2D_enc;
+	this->glCompressedTexSubImage2D = &glCompressedTexSubImage2D_enc;
+	this->glCopyTexImage2D = &glCopyTexImage2D_enc;
+	this->glCopyTexSubImage2D = &glCopyTexSubImage2D_enc;
+	this->glCullFace = &glCullFace_enc;
+	this->glDeleteBuffers = &glDeleteBuffers_enc;
+	this->glDeleteTextures = &glDeleteTextures_enc;
+	this->glDepthFunc = &glDepthFunc_enc;
+	this->glDepthMask = &glDepthMask_enc;
+	this->glDepthRangex = &glDepthRangex_enc;
+	this->glDisable = &glDisable_enc;
+	this->glDisableClientState = &glDisableClientState_enc;
+	this->glDrawArrays = &glDrawArrays_enc;
+	this->glDrawElements = (glDrawElements_client_proc_t) &enc_unsupported;
+	this->glEnable = &glEnable_enc;
+	this->glEnableClientState = &glEnableClientState_enc;
+	this->glFinish = &glFinish_enc;
+	this->glFlush = &glFlush_enc;
+	this->glFogx = &glFogx_enc;
+	this->glFogxv = &glFogxv_enc;
+	this->glFrontFace = &glFrontFace_enc;
+	this->glFrustumx = &glFrustumx_enc;
+	this->glGetBooleanv = &glGetBooleanv_enc;
+	this->glGetBufferParameteriv = &glGetBufferParameteriv_enc;
+	this->glClipPlanex = &glClipPlanex_enc;
+	this->glGenBuffers = &glGenBuffers_enc;
+	this->glGenTextures = &glGenTextures_enc;
+	this->glGetError = &glGetError_enc;
+	this->glGetFixedv = &glGetFixedv_enc;
+	this->glGetIntegerv = &glGetIntegerv_enc;
+	this->glGetLightxv = &glGetLightxv_enc;
+	this->glGetMaterialxv = &glGetMaterialxv_enc;
+	this->glGetPointerv = (glGetPointerv_client_proc_t) &enc_unsupported;
+	this->glGetString = (glGetString_client_proc_t) &enc_unsupported;
+	this->glGetTexEnviv = &glGetTexEnviv_enc;
+	this->glGetTexEnvxv = &glGetTexEnvxv_enc;
+	this->glGetTexParameteriv = &glGetTexParameteriv_enc;
+	this->glGetTexParameterxv = &glGetTexParameterxv_enc;
+	this->glHint = &glHint_enc;
+	this->glIsBuffer = &glIsBuffer_enc;
+	this->glIsEnabled = &glIsEnabled_enc;
+	this->glIsTexture = &glIsTexture_enc;
+	this->glLightModelx = &glLightModelx_enc;
+	this->glLightModelxv = &glLightModelxv_enc;
+	this->glLightx = &glLightx_enc;
+	this->glLightxv = &glLightxv_enc;
+	this->glLineWidthx = &glLineWidthx_enc;
+	this->glLoadIdentity = &glLoadIdentity_enc;
+	this->glLoadMatrixx = &glLoadMatrixx_enc;
+	this->glLogicOp = &glLogicOp_enc;
+	this->glMaterialx = &glMaterialx_enc;
+	this->glMaterialxv = &glMaterialxv_enc;
+	this->glMatrixMode = &glMatrixMode_enc;
+	this->glMultMatrixx = &glMultMatrixx_enc;
+	this->glMultiTexCoord4x = &glMultiTexCoord4x_enc;
+	this->glNormal3x = &glNormal3x_enc;
+	this->glNormalPointer = (glNormalPointer_client_proc_t) &enc_unsupported;
+	this->glOrthox = &glOrthox_enc;
+	this->glPixelStorei = &glPixelStorei_enc;
+	this->glPointParameterx = &glPointParameterx_enc;
+	this->glPointParameterxv = &glPointParameterxv_enc;
+	this->glPointSizex = &glPointSizex_enc;
+	this->glPolygonOffsetx = &glPolygonOffsetx_enc;
+	this->glPopMatrix = &glPopMatrix_enc;
+	this->glPushMatrix = &glPushMatrix_enc;
+	this->glReadPixels = &glReadPixels_enc;
+	this->glRotatex = &glRotatex_enc;
+	this->glSampleCoverage = &glSampleCoverage_enc;
+	this->glSampleCoveragex = &glSampleCoveragex_enc;
+	this->glScalex = &glScalex_enc;
+	this->glScissor = &glScissor_enc;
+	this->glShadeModel = &glShadeModel_enc;
+	this->glStencilFunc = &glStencilFunc_enc;
+	this->glStencilMask = &glStencilMask_enc;
+	this->glStencilOp = &glStencilOp_enc;
+	this->glTexCoordPointer = (glTexCoordPointer_client_proc_t) &enc_unsupported;
+	this->glTexEnvi = &glTexEnvi_enc;
+	this->glTexEnvx = &glTexEnvx_enc;
+	this->glTexEnviv = &glTexEnviv_enc;
+	this->glTexEnvxv = &glTexEnvxv_enc;
+	this->glTexImage2D = &glTexImage2D_enc;
+	this->glTexParameteri = &glTexParameteri_enc;
+	this->glTexParameterx = &glTexParameterx_enc;
+	this->glTexParameteriv = &glTexParameteriv_enc;
+	this->glTexParameterxv = &glTexParameterxv_enc;
+	this->glTexSubImage2D = &glTexSubImage2D_enc;
+	this->glTranslatex = &glTranslatex_enc;
+	this->glVertexPointer = (glVertexPointer_client_proc_t) &enc_unsupported;
+	this->glViewport = &glViewport_enc;
+	this->glPointSizePointerOES = (glPointSizePointerOES_client_proc_t) &enc_unsupported;
+	this->glVertexPointerOffset = &glVertexPointerOffset_enc;
+	this->glColorPointerOffset = &glColorPointerOffset_enc;
+	this->glNormalPointerOffset = &glNormalPointerOffset_enc;
+	this->glPointSizePointerOffset = &glPointSizePointerOffset_enc;
+	this->glTexCoordPointerOffset = &glTexCoordPointerOffset_enc;
+	this->glWeightPointerOffset = &glWeightPointerOffset_enc;
+	this->glMatrixIndexPointerOffset = &glMatrixIndexPointerOffset_enc;
+	this->glVertexPointerData = &glVertexPointerData_enc;
+	this->glColorPointerData = &glColorPointerData_enc;
+	this->glNormalPointerData = &glNormalPointerData_enc;
+	this->glTexCoordPointerData = &glTexCoordPointerData_enc;
+	this->glPointSizePointerData = &glPointSizePointerData_enc;
+	this->glWeightPointerData = &glWeightPointerData_enc;
+	this->glMatrixIndexPointerData = &glMatrixIndexPointerData_enc;
+	this->glDrawElementsOffset = &glDrawElementsOffset_enc;
+	this->glDrawElementsData = &glDrawElementsData_enc;
+	this->glGetCompressedTextureFormats = &glGetCompressedTextureFormats_enc;
+	this->glFinishRoundTrip = &glFinishRoundTrip_enc;
+	this->glBlendEquationSeparateOES = &glBlendEquationSeparateOES_enc;
+	this->glBlendFuncSeparateOES = &glBlendFuncSeparateOES_enc;
+	this->glBlendEquationOES = &glBlendEquationOES_enc;
+	this->glDrawTexsOES = &glDrawTexsOES_enc;
+	this->glDrawTexiOES = &glDrawTexiOES_enc;
+	this->glDrawTexxOES = &glDrawTexxOES_enc;
+	this->glDrawTexsvOES = &glDrawTexsvOES_enc;
+	this->glDrawTexivOES = &glDrawTexivOES_enc;
+	this->glDrawTexxvOES = &glDrawTexxvOES_enc;
+	this->glDrawTexfOES = &glDrawTexfOES_enc;
+	this->glDrawTexfvOES = &glDrawTexfvOES_enc;
+	this->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES_enc;
+	this->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES_enc;
+	this->glAlphaFuncxOES = &glAlphaFuncxOES_enc;
+	this->glClearColorxOES = &glClearColorxOES_enc;
+	this->glClearDepthxOES = &glClearDepthxOES_enc;
+	this->glClipPlanexOES = &glClipPlanexOES_enc;
+	this->glClipPlanexIMG = &glClipPlanexIMG_enc;
+	this->glColor4xOES = &glColor4xOES_enc;
+	this->glDepthRangexOES = &glDepthRangexOES_enc;
+	this->glFogxOES = &glFogxOES_enc;
+	this->glFogxvOES = &glFogxvOES_enc;
+	this->glFrustumxOES = &glFrustumxOES_enc;
+	this->glGetClipPlanexOES = &glGetClipPlanexOES_enc;
+	this->glGetClipPlanex = &glGetClipPlanex_enc;
+	this->glGetFixedvOES = &glGetFixedvOES_enc;
+	this->glGetLightxvOES = &glGetLightxvOES_enc;
+	this->glGetMaterialxvOES = &glGetMaterialxvOES_enc;
+	this->glGetTexEnvxvOES = &glGetTexEnvxvOES_enc;
+	this->glGetTexParameterxvOES = &glGetTexParameterxvOES_enc;
+	this->glLightModelxOES = &glLightModelxOES_enc;
+	this->glLightModelxvOES = &glLightModelxvOES_enc;
+	this->glLightxOES = &glLightxOES_enc;
+	this->glLightxvOES = &glLightxvOES_enc;
+	this->glLineWidthxOES = &glLineWidthxOES_enc;
+	this->glLoadMatrixxOES = &glLoadMatrixxOES_enc;
+	this->glMaterialxOES = &glMaterialxOES_enc;
+	this->glMaterialxvOES = &glMaterialxvOES_enc;
+	this->glMultMatrixxOES = &glMultMatrixxOES_enc;
+	this->glMultiTexCoord4xOES = &glMultiTexCoord4xOES_enc;
+	this->glNormal3xOES = &glNormal3xOES_enc;
+	this->glOrthoxOES = &glOrthoxOES_enc;
+	this->glPointParameterxOES = &glPointParameterxOES_enc;
+	this->glPointParameterxvOES = &glPointParameterxvOES_enc;
+	this->glPointSizexOES = &glPointSizexOES_enc;
+	this->glPolygonOffsetxOES = &glPolygonOffsetxOES_enc;
+	this->glRotatexOES = &glRotatexOES_enc;
+	this->glSampleCoveragexOES = &glSampleCoveragexOES_enc;
+	this->glScalexOES = &glScalexOES_enc;
+	this->glTexEnvxOES = &glTexEnvxOES_enc;
+	this->glTexEnvxvOES = &glTexEnvxvOES_enc;
+	this->glTexParameterxOES = &glTexParameterxOES_enc;
+	this->glTexParameterxvOES = &glTexParameterxvOES_enc;
+	this->glTranslatexOES = &glTranslatexOES_enc;
+	this->glIsRenderbufferOES = &glIsRenderbufferOES_enc;
+	this->glBindRenderbufferOES = &glBindRenderbufferOES_enc;
+	this->glDeleteRenderbuffersOES = &glDeleteRenderbuffersOES_enc;
+	this->glGenRenderbuffersOES = &glGenRenderbuffersOES_enc;
+	this->glRenderbufferStorageOES = &glRenderbufferStorageOES_enc;
+	this->glGetRenderbufferParameterivOES = &glGetRenderbufferParameterivOES_enc;
+	this->glIsFramebufferOES = &glIsFramebufferOES_enc;
+	this->glBindFramebufferOES = &glBindFramebufferOES_enc;
+	this->glDeleteFramebuffersOES = &glDeleteFramebuffersOES_enc;
+	this->glGenFramebuffersOES = &glGenFramebuffersOES_enc;
+	this->glCheckFramebufferStatusOES = &glCheckFramebufferStatusOES_enc;
+	this->glFramebufferRenderbufferOES = &glFramebufferRenderbufferOES_enc;
+	this->glFramebufferTexture2DOES = &glFramebufferTexture2DOES_enc;
+	this->glGetFramebufferAttachmentParameterivOES = &glGetFramebufferAttachmentParameterivOES_enc;
+	this->glGenerateMipmapOES = &glGenerateMipmapOES_enc;
+	this->glMapBufferOES = (glMapBufferOES_client_proc_t) &enc_unsupported;
+	this->glUnmapBufferOES = &glUnmapBufferOES_enc;
+	this->glGetBufferPointervOES = (glGetBufferPointervOES_client_proc_t) &enc_unsupported;
+	this->glCurrentPaletteMatrixOES = &glCurrentPaletteMatrixOES_enc;
+	this->glLoadPaletteFromModelViewMatrixOES = &glLoadPaletteFromModelViewMatrixOES_enc;
+	this->glMatrixIndexPointerOES = (glMatrixIndexPointerOES_client_proc_t) &enc_unsupported;
+	this->glWeightPointerOES = (glWeightPointerOES_client_proc_t) &enc_unsupported;
+	this->glQueryMatrixxOES = &glQueryMatrixxOES_enc;
+	this->glDepthRangefOES = &glDepthRangefOES_enc;
+	this->glFrustumfOES = &glFrustumfOES_enc;
+	this->glOrthofOES = &glOrthofOES_enc;
+	this->glClipPlanefOES = &glClipPlanefOES_enc;
+	this->glClipPlanefIMG = &glClipPlanefIMG_enc;
+	this->glGetClipPlanefOES = &glGetClipPlanefOES_enc;
+	this->glClearDepthfOES = &glClearDepthfOES_enc;
+	this->glTexGenfOES = &glTexGenfOES_enc;
+	this->glTexGenfvOES = &glTexGenfvOES_enc;
+	this->glTexGeniOES = &glTexGeniOES_enc;
+	this->glTexGenivOES = &glTexGenivOES_enc;
+	this->glTexGenxOES = &glTexGenxOES_enc;
+	this->glTexGenxvOES = &glTexGenxvOES_enc;
+	this->glGetTexGenfvOES = &glGetTexGenfvOES_enc;
+	this->glGetTexGenivOES = &glGetTexGenivOES_enc;
+	this->glGetTexGenxvOES = &glGetTexGenxvOES_enc;
+	this->glBindVertexArrayOES = &glBindVertexArrayOES_enc;
+	this->glDeleteVertexArraysOES = &glDeleteVertexArraysOES_enc;
+	this->glGenVertexArraysOES = &glGenVertexArraysOES_enc;
+	this->glIsVertexArrayOES = &glIsVertexArrayOES_enc;
+	this->glDiscardFramebufferEXT = &glDiscardFramebufferEXT_enc;
+	this->glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) &enc_unsupported;
+	this->glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) &enc_unsupported;
+	this->glMultiDrawArraysSUN = (glMultiDrawArraysSUN_client_proc_t) &enc_unsupported;
+	this->glMultiDrawElementsSUN = (glMultiDrawElementsSUN_client_proc_t) &enc_unsupported;
+	this->glRenderbufferStorageMultisampleIMG = &glRenderbufferStorageMultisampleIMG_enc;
+	this->glFramebufferTexture2DMultisampleIMG = &glFramebufferTexture2DMultisampleIMG_enc;
+	this->glDeleteFencesNV = &glDeleteFencesNV_enc;
+	this->glGenFencesNV = &glGenFencesNV_enc;
+	this->glIsFenceNV = &glIsFenceNV_enc;
+	this->glTestFenceNV = &glTestFenceNV_enc;
+	this->glGetFenceivNV = &glGetFenceivNV_enc;
+	this->glFinishFenceNV = &glFinishFenceNV_enc;
+	this->glSetFenceNV = &glSetFenceNV_enc;
+	this->glGetDriverControlsQCOM = &glGetDriverControlsQCOM_enc;
+	this->glGetDriverControlStringQCOM = &glGetDriverControlStringQCOM_enc;
+	this->glEnableDriverControlQCOM = &glEnableDriverControlQCOM_enc;
+	this->glDisableDriverControlQCOM = &glDisableDriverControlQCOM_enc;
+	this->glExtGetTexturesQCOM = &glExtGetTexturesQCOM_enc;
+	this->glExtGetBuffersQCOM = &glExtGetBuffersQCOM_enc;
+	this->glExtGetRenderbuffersQCOM = &glExtGetRenderbuffersQCOM_enc;
+	this->glExtGetFramebuffersQCOM = &glExtGetFramebuffersQCOM_enc;
+	this->glExtGetTexLevelParameterivQCOM = &glExtGetTexLevelParameterivQCOM_enc;
+	this->glExtTexObjectStateOverrideiQCOM = &glExtTexObjectStateOverrideiQCOM_enc;
+	this->glExtGetTexSubImageQCOM = &glExtGetTexSubImageQCOM_enc;
+	this->glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetShadersQCOM = &glExtGetShadersQCOM_enc;
+	this->glExtGetProgramsQCOM = &glExtGetProgramsQCOM_enc;
+	this->glExtIsProgramBinaryQCOM = &glExtIsProgramBinaryQCOM_enc;
+	this->glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) &enc_unsupported;
+	this->glStartTilingQCOM = &glStartTilingQCOM_enc;
+	this->glEndTilingQCOM = &glEndTilingQCOM_enc;
 }
 
diff --git a/opengl/system/GLESv1_enc/gl_enc.h b/opengl/system/GLESv1_enc/gl_enc.h
index 2899b66..03ebb42 100644
--- a/opengl/system/GLESv1_enc/gl_enc.h
+++ b/opengl/system/GLESv1_enc/gl_enc.h
@@ -16,301 +16,6 @@ struct gl_encoder_context_t : public gl_client_context_t {
 	IOStream *m_stream;
 
 	gl_encoder_context_t(IOStream *stream);
-
-
 };
 
-extern "C" {
-	void glAlphaFunc_enc(void *self , GLenum func, GLclampf ref);
-	void glClearColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-	void glClearDepthf_enc(void *self , GLclampf depth);
-	void glClipPlanef_enc(void *self , GLenum plane, const GLfloat* equation);
-	void glColor4f_enc(void *self , GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-	void glDepthRangef_enc(void *self , GLclampf zNear, GLclampf zFar);
-	void glFogf_enc(void *self , GLenum pname, GLfloat param);
-	void glFogfv_enc(void *self , GLenum pname, const GLfloat* params);
-	void glFrustumf_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
-	void glGetClipPlanef_enc(void *self , GLenum pname, GLfloat* eqn);
-	void glGetFloatv_enc(void *self , GLenum pname, GLfloat* params);
-	void glGetLightfv_enc(void *self , GLenum light, GLenum pname, GLfloat* params);
-	void glGetMaterialfv_enc(void *self , GLenum face, GLenum pname, GLfloat* params);
-	void glGetTexEnvfv_enc(void *self , GLenum env, GLenum pname, GLfloat* params);
-	void glGetTexParameterfv_enc(void *self , GLenum target, GLenum pname, GLfloat* params);
-	void glLightModelf_enc(void *self , GLenum pname, GLfloat param);
-	void glLightModelfv_enc(void *self , GLenum pname, const GLfloat* params);
-	void glLightf_enc(void *self , GLenum light, GLenum pname, GLfloat param);
-	void glLightfv_enc(void *self , GLenum light, GLenum pname, const GLfloat* params);
-	void glLineWidth_enc(void *self , GLfloat width);
-	void glLoadMatrixf_enc(void *self , const GLfloat* m);
-	void glMaterialf_enc(void *self , GLenum face, GLenum pname, GLfloat param);
-	void glMaterialfv_enc(void *self , GLenum face, GLenum pname, const GLfloat* params);
-	void glMultMatrixf_enc(void *self , const GLfloat* m);
-	void glMultiTexCoord4f_enc(void *self , GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-	void glNormal3f_enc(void *self , GLfloat nx, GLfloat ny, GLfloat nz);
-	void glOrthof_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
-	void glPointParameterf_enc(void *self , GLenum pname, GLfloat param);
-	void glPointParameterfv_enc(void *self , GLenum pname, const GLfloat* params);
-	void glPointSize_enc(void *self , GLfloat size);
-	void glPolygonOffset_enc(void *self , GLfloat factor, GLfloat units);
-	void glRotatef_enc(void *self , GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-	void glScalef_enc(void *self , GLfloat x, GLfloat y, GLfloat z);
-	void glTexEnvf_enc(void *self , GLenum target, GLenum pname, GLfloat param);
-	void glTexEnvfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params);
-	void glTexParameterf_enc(void *self , GLenum target, GLenum pname, GLfloat param);
-	void glTexParameterfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params);
-	void glTranslatef_enc(void *self , GLfloat x, GLfloat y, GLfloat z);
-	void glActiveTexture_enc(void *self , GLenum texture);
-	void glAlphaFuncx_enc(void *self , GLenum func, GLclampx ref);
-	void glBindBuffer_enc(void *self , GLenum target, GLuint buffer);
-	void glBindTexture_enc(void *self , GLenum target, GLuint texture);
-	void glBlendFunc_enc(void *self , GLenum sfactor, GLenum dfactor);
-	void glBufferData_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
-	void glBufferSubData_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
-	void glClear_enc(void *self , GLbitfield mask);
-	void glClearColorx_enc(void *self , GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
-	void glClearDepthx_enc(void *self , GLclampx depth);
-	void glClearStencil_enc(void *self , GLint s);
-	void glClientActiveTexture_enc(void *self , GLenum texture);
-	void glColor4ub_enc(void *self , GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-	void glColor4x_enc(void *self , GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
-	void glColorMask_enc(void *self , GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-	void glColorPointer_enc(void *self , GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-	void glCompressedTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
-	void glCompressedTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
-	void glCopyTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-	void glCopyTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-	void glCullFace_enc(void *self , GLenum mode);
-	void glDeleteBuffers_enc(void *self , GLsizei n, const GLuint* buffers);
-	void glDeleteTextures_enc(void *self , GLsizei n, const GLuint* textures);
-	void glDepthFunc_enc(void *self , GLenum func);
-	void glDepthMask_enc(void *self , GLboolean flag);
-	void glDepthRangex_enc(void *self , GLclampx zNear, GLclampx zFar);
-	void glDisable_enc(void *self , GLenum cap);
-	void glDisableClientState_enc(void *self , GLenum array);
-	void glDrawArrays_enc(void *self , GLenum mode, GLint first, GLsizei count);
-	void glDrawElements_enc(void *self , GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-	void glEnable_enc(void *self , GLenum cap);
-	void glEnableClientState_enc(void *self , GLenum array);
-	void glFinish_enc(void *self );
-	void glFlush_enc(void *self );
-	void glFogx_enc(void *self , GLenum pname, GLfixed param);
-	void glFogxv_enc(void *self , GLenum pname, const GLfixed* params);
-	void glFrontFace_enc(void *self , GLenum mode);
-	void glFrustumx_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
-	void glGetBooleanv_enc(void *self , GLenum pname, GLboolean* params);
-	void glGetBufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params);
-	void glClipPlanex_enc(void *self , GLenum pname, const GLfixed* eqn);
-	void glGenBuffers_enc(void *self , GLsizei n, GLuint* buffers);
-	void glGenTextures_enc(void *self , GLsizei n, GLuint* textures);
-	GLenum glGetError_enc(void *self );
-	void glGetFixedv_enc(void *self , GLenum pname, GLfixed* params);
-	void glGetIntegerv_enc(void *self , GLenum pname, GLint* params);
-	void glGetLightxv_enc(void *self , GLenum light, GLenum pname, GLfixed* params);
-	void glGetMaterialxv_enc(void *self , GLenum face, GLenum pname, GLfixed* params);
-	void glGetPointerv_enc(void *self , GLenum pname, GLvoid** params);
-	const GLubyte* glGetString_enc(void *self , GLenum name);
-	void glGetTexEnviv_enc(void *self , GLenum env, GLenum pname, GLint* params);
-	void glGetTexEnvxv_enc(void *self , GLenum env, GLenum pname, GLfixed* params);
-	void glGetTexParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params);
-	void glGetTexParameterxv_enc(void *self , GLenum target, GLenum pname, GLfixed* params);
-	void glHint_enc(void *self , GLenum target, GLenum mode);
-	GLboolean glIsBuffer_enc(void *self , GLuint buffer);
-	GLboolean glIsEnabled_enc(void *self , GLenum cap);
-	GLboolean glIsTexture_enc(void *self , GLuint texture);
-	void glLightModelx_enc(void *self , GLenum pname, GLfixed param);
-	void glLightModelxv_enc(void *self , GLenum pname, const GLfixed* params);
-	void glLightx_enc(void *self , GLenum light, GLenum pname, GLfixed param);
-	void glLightxv_enc(void *self , GLenum light, GLenum pname, const GLfixed* params);
-	void glLineWidthx_enc(void *self , GLfixed width);
-	void glLoadIdentity_enc(void *self );
-	void glLoadMatrixx_enc(void *self , const GLfixed* m);
-	void glLogicOp_enc(void *self , GLenum opcode);
-	void glMaterialx_enc(void *self , GLenum face, GLenum pname, GLfixed param);
-	void glMaterialxv_enc(void *self , GLenum face, GLenum pname, const GLfixed* params);
-	void glMatrixMode_enc(void *self , GLenum mode);
-	void glMultMatrixx_enc(void *self , const GLfixed* m);
-	void glMultiTexCoord4x_enc(void *self , GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
-	void glNormal3x_enc(void *self , GLfixed nx, GLfixed ny, GLfixed nz);
-	void glNormalPointer_enc(void *self , GLenum type, GLsizei stride, const GLvoid* pointer);
-	void glOrthox_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
-	void glPixelStorei_enc(void *self , GLenum pname, GLint param);
-	void glPointParameterx_enc(void *self , GLenum pname, GLfixed param);
-	void glPointParameterxv_enc(void *self , GLenum pname, const GLfixed* params);
-	void glPointSizex_enc(void *self , GLfixed size);
-	void glPolygonOffsetx_enc(void *self , GLfixed factor, GLfixed units);
-	void glPopMatrix_enc(void *self );
-	void glPushMatrix_enc(void *self );
-	void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-	void glRotatex_enc(void *self , GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
-	void glSampleCoverage_enc(void *self , GLclampf value, GLboolean invert);
-	void glSampleCoveragex_enc(void *self , GLclampx value, GLboolean invert);
-	void glScalex_enc(void *self , GLfixed x, GLfixed y, GLfixed z);
-	void glScissor_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height);
-	void glShadeModel_enc(void *self , GLenum mode);
-	void glStencilFunc_enc(void *self , GLenum func, GLint ref, GLuint mask);
-	void glStencilMask_enc(void *self , GLuint mask);
-	void glStencilOp_enc(void *self , GLenum fail, GLenum zfail, GLenum zpass);
-	void glTexCoordPointer_enc(void *self , GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-	void glTexEnvi_enc(void *self , GLenum target, GLenum pname, GLint param);
-	void glTexEnvx_enc(void *self , GLenum target, GLenum pname, GLfixed param);
-	void glTexEnviv_enc(void *self , GLenum target, GLenum pname, const GLint* params);
-	void glTexEnvxv_enc(void *self , GLenum target, GLenum pname, const GLfixed* params);
-	void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-	void glTexParameteri_enc(void *self , GLenum target, GLenum pname, GLint param);
-	void glTexParameterx_enc(void *self , GLenum target, GLenum pname, GLfixed param);
-	void glTexParameteriv_enc(void *self , GLenum target, GLenum pname, const GLint* params);
-	void glTexParameterxv_enc(void *self , GLenum target, GLenum pname, const GLfixed* params);
-	void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-	void glTranslatex_enc(void *self , GLfixed x, GLfixed y, GLfixed z);
-	void glVertexPointer_enc(void *self , GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-	void glViewport_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height);
-	void glPointSizePointerOES_enc(void *self , GLenum type, GLsizei stride, const GLvoid* pointer);
-	void glVertexPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset);
-	void glColorPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset);
-	void glNormalPointerOffset_enc(void *self , GLenum type, GLsizei stride, GLuint offset);
-	void glPointSizePointerOffset_enc(void *self , GLenum type, GLsizei stride, GLuint offset);
-	void glTexCoordPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset);
-	void glWeightPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset);
-	void glMatrixIndexPointerOffset_enc(void *self , GLint size, GLenum type, GLsizei stride, GLuint offset);
-	void glVertexPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glColorPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glNormalPointerData_enc(void *self , GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glTexCoordPointerData_enc(void *self , GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glPointSizePointerData_enc(void *self , GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glWeightPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glMatrixIndexPointerData_enc(void *self , GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen);
-	void glDrawElementsOffset_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset);
-	void glDrawElementsData_enc(void *self , GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen);
-	void glGetCompressedTextureFormats_enc(void *self , int count, GLint* formats);
-	int glFinishRoundTrip_enc(void *self );
-	void glBlendEquationSeparateOES_enc(void *self , GLenum modeRGB, GLenum modeAlpha);
-	void glBlendFuncSeparateOES_enc(void *self , GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-	void glBlendEquationOES_enc(void *self , GLenum mode);
-	void glDrawTexsOES_enc(void *self , GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
-	void glDrawTexiOES_enc(void *self , GLint x, GLint y, GLint z, GLint width, GLint height);
-	void glDrawTexxOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
-	void glDrawTexsvOES_enc(void *self , const GLshort* coords);
-	void glDrawTexivOES_enc(void *self , const GLint* coords);
-	void glDrawTexxvOES_enc(void *self , const GLfixed* coords);
-	void glDrawTexfOES_enc(void *self , GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
-	void glDrawTexfvOES_enc(void *self , const GLfloat* coords);
-	void glEGLImageTargetTexture2DOES_enc(void *self , GLenum target, GLeglImageOES image);
-	void glEGLImageTargetRenderbufferStorageOES_enc(void *self , GLenum target, GLeglImageOES image);
-	void glAlphaFuncxOES_enc(void *self , GLenum func, GLclampx ref);
-	void glClearColorxOES_enc(void *self , GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha);
-	void glClearDepthxOES_enc(void *self , GLclampx depth);
-	void glClipPlanexOES_enc(void *self , GLenum plane, const GLfixed* equation);
-	void glClipPlanexIMG_enc(void *self , GLenum plane, const GLfixed* equation);
-	void glColor4xOES_enc(void *self , GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
-	void glDepthRangexOES_enc(void *self , GLclampx zNear, GLclampx zFar);
-	void glFogxOES_enc(void *self , GLenum pname, GLfixed param);
-	void glFogxvOES_enc(void *self , GLenum pname, const GLfixed* params);
-	void glFrustumxOES_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
-	void glGetClipPlanexOES_enc(void *self , GLenum pname, GLfixed* eqn);
-	void glGetClipPlanex_enc(void *self , GLenum pname, GLfixed* eqn);
-	void glGetFixedvOES_enc(void *self , GLenum pname, GLfixed* params);
-	void glGetLightxvOES_enc(void *self , GLenum light, GLenum pname, GLfixed* params);
-	void glGetMaterialxvOES_enc(void *self , GLenum face, GLenum pname, GLfixed* params);
-	void glGetTexEnvxvOES_enc(void *self , GLenum env, GLenum pname, GLfixed* params);
-	void glGetTexParameterxvOES_enc(void *self , GLenum target, GLenum pname, GLfixed* params);
-	void glLightModelxOES_enc(void *self , GLenum pname, GLfixed param);
-	void glLightModelxvOES_enc(void *self , GLenum pname, const GLfixed* params);
-	void glLightxOES_enc(void *self , GLenum light, GLenum pname, GLfixed param);
-	void glLightxvOES_enc(void *self , GLenum light, GLenum pname, const GLfixed* params);
-	void glLineWidthxOES_enc(void *self , GLfixed width);
-	void glLoadMatrixxOES_enc(void *self , const GLfixed* m);
-	void glMaterialxOES_enc(void *self , GLenum face, GLenum pname, GLfixed param);
-	void glMaterialxvOES_enc(void *self , GLenum face, GLenum pname, const GLfixed* params);
-	void glMultMatrixxOES_enc(void *self , const GLfixed* m);
-	void glMultiTexCoord4xOES_enc(void *self , GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
-	void glNormal3xOES_enc(void *self , GLfixed nx, GLfixed ny, GLfixed nz);
-	void glOrthoxOES_enc(void *self , GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar);
-	void glPointParameterxOES_enc(void *self , GLenum pname, GLfixed param);
-	void glPointParameterxvOES_enc(void *self , GLenum pname, const GLfixed* params);
-	void glPointSizexOES_enc(void *self , GLfixed size);
-	void glPolygonOffsetxOES_enc(void *self , GLfixed factor, GLfixed units);
-	void glRotatexOES_enc(void *self , GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
-	void glSampleCoveragexOES_enc(void *self , GLclampx value, GLboolean invert);
-	void glScalexOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z);
-	void glTexEnvxOES_enc(void *self , GLenum target, GLenum pname, GLfixed param);
-	void glTexEnvxvOES_enc(void *self , GLenum target, GLenum pname, const GLfixed* params);
-	void glTexParameterxOES_enc(void *self , GLenum target, GLenum pname, GLfixed param);
-	void glTexParameterxvOES_enc(void *self , GLenum target, GLenum pname, const GLfixed* params);
-	void glTranslatexOES_enc(void *self , GLfixed x, GLfixed y, GLfixed z);
-	GLboolean glIsRenderbufferOES_enc(void *self , GLuint renderbuffer);
-	void glBindRenderbufferOES_enc(void *self , GLenum target, GLuint renderbuffer);
-	void glDeleteRenderbuffersOES_enc(void *self , GLsizei n, const GLuint* renderbuffers);
-	void glGenRenderbuffersOES_enc(void *self , GLsizei n, GLuint* renderbuffers);
-	void glRenderbufferStorageOES_enc(void *self , GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-	void glGetRenderbufferParameterivOES_enc(void *self , GLenum target, GLenum pname, GLint* params);
-	GLboolean glIsFramebufferOES_enc(void *self , GLuint framebuffer);
-	void glBindFramebufferOES_enc(void *self , GLenum target, GLuint framebuffer);
-	void glDeleteFramebuffersOES_enc(void *self , GLsizei n, const GLuint* framebuffers);
-	void glGenFramebuffersOES_enc(void *self , GLsizei n, GLuint* framebuffers);
-	GLenum glCheckFramebufferStatusOES_enc(void *self , GLenum target);
-	void glFramebufferRenderbufferOES_enc(void *self , GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-	void glFramebufferTexture2DOES_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-	void glGetFramebufferAttachmentParameterivOES_enc(void *self , GLenum target, GLenum attachment, GLenum pname, GLint* params);
-	void glGenerateMipmapOES_enc(void *self , GLenum target);
-	void* glMapBufferOES_enc(void *self , GLenum target, GLenum access);
-	GLboolean glUnmapBufferOES_enc(void *self , GLenum target);
-	void glGetBufferPointervOES_enc(void *self , GLenum target, GLenum pname, GLvoid** params);
-	void glCurrentPaletteMatrixOES_enc(void *self , GLuint matrixpaletteindex);
-	void glLoadPaletteFromModelViewMatrixOES_enc(void *self );
-	void glMatrixIndexPointerOES_enc(void *self , GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-	void glWeightPointerOES_enc(void *self , GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);
-	GLbitfield glQueryMatrixxOES_enc(void *self , GLfixed* mantissa, GLint* exponent);
-	void glDepthRangefOES_enc(void *self , GLclampf zNear, GLclampf zFar);
-	void glFrustumfOES_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
-	void glOrthofOES_enc(void *self , GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
-	void glClipPlanefOES_enc(void *self , GLenum plane, const GLfloat* equation);
-	void glClipPlanefIMG_enc(void *self , GLenum plane, const GLfloat* equation);
-	void glGetClipPlanefOES_enc(void *self , GLenum pname, GLfloat* eqn);
-	void glClearDepthfOES_enc(void *self , GLclampf depth);
-	void glTexGenfOES_enc(void *self , GLenum coord, GLenum pname, GLfloat param);
-	void glTexGenfvOES_enc(void *self , GLenum coord, GLenum pname, const GLfloat* params);
-	void glTexGeniOES_enc(void *self , GLenum coord, GLenum pname, GLint param);
-	void glTexGenivOES_enc(void *self , GLenum coord, GLenum pname, const GLint* params);
-	void glTexGenxOES_enc(void *self , GLenum coord, GLenum pname, GLfixed param);
-	void glTexGenxvOES_enc(void *self , GLenum coord, GLenum pname, const GLfixed* params);
-	void glGetTexGenfvOES_enc(void *self , GLenum coord, GLenum pname, GLfloat* params);
-	void glGetTexGenivOES_enc(void *self , GLenum coord, GLenum pname, GLint* params);
-	void glGetTexGenxvOES_enc(void *self , GLenum coord, GLenum pname, GLfixed* params);
-	void glBindVertexArrayOES_enc(void *self , GLuint array);
-	void glDeleteVertexArraysOES_enc(void *self , GLsizei n, const GLuint* arrays);
-	void glGenVertexArraysOES_enc(void *self , GLsizei n, GLuint* arrays);
-	GLboolean glIsVertexArrayOES_enc(void *self , GLuint array);
-	void glDiscardFramebufferEXT_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments);
-	void glMultiDrawArraysEXT_enc(void *self , GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount);
-	void glMultiDrawElementsEXT_enc(void *self , GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount);
-	void glMultiDrawArraysSUN_enc(void *self , GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
-	void glMultiDrawElementsSUN_enc(void *self , GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
-	void glRenderbufferStorageMultisampleIMG_enc(void *self , GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-	void glFramebufferTexture2DMultisampleIMG_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
-	void glDeleteFencesNV_enc(void *self , GLsizei n, const GLuint* fences);
-	void glGenFencesNV_enc(void *self , GLsizei n, GLuint* fences);
-	GLboolean glIsFenceNV_enc(void *self , GLuint fence);
-	GLboolean glTestFenceNV_enc(void *self , GLuint fence);
-	void glGetFenceivNV_enc(void *self , GLuint fence, GLenum pname, GLint* params);
-	void glFinishFenceNV_enc(void *self , GLuint fence);
-	void glSetFenceNV_enc(void *self , GLuint fence, GLenum condition);
-	void glGetDriverControlsQCOM_enc(void *self , GLint* num, GLsizei size, GLuint* driverControls);
-	void glGetDriverControlStringQCOM_enc(void *self , GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString);
-	void glEnableDriverControlQCOM_enc(void *self , GLuint driverControl);
-	void glDisableDriverControlQCOM_enc(void *self , GLuint driverControl);
-	void glExtGetTexturesQCOM_enc(void *self , GLuint* textures, GLint maxTextures, GLint* numTextures);
-	void glExtGetBuffersQCOM_enc(void *self , GLuint* buffers, GLint maxBuffers, GLint* numBuffers);
-	void glExtGetRenderbuffersQCOM_enc(void *self , GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);
-	void glExtGetFramebuffersQCOM_enc(void *self , GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);
-	void glExtGetTexLevelParameterivQCOM_enc(void *self , GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params);
-	void glExtTexObjectStateOverrideiQCOM_enc(void *self , GLenum target, GLenum pname, GLint param);
-	void glExtGetTexSubImageQCOM_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels);
-	void glExtGetBufferPointervQCOM_enc(void *self , GLenum target, GLvoid** params);
-	void glExtGetShadersQCOM_enc(void *self , GLuint* shaders, GLint maxShaders, GLint* numShaders);
-	void glExtGetProgramsQCOM_enc(void *self , GLuint* programs, GLint maxPrograms, GLint* numPrograms);
-	GLboolean glExtIsProgramBinaryQCOM_enc(void *self , GLuint program);
-	void glExtGetProgramBinarySourceQCOM_enc(void *self , GLuint program, GLenum shadertype, GLchar* source, GLint* length);
-	void glStartTilingQCOM_enc(void *self , GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);
-	void glEndTilingQCOM_enc(void *self , GLbitfield preserveMask);
-};
-#endif
+#endif  // GUARD_gl_encoder_context_t
\ No newline at end of file
diff --git a/opengl/system/GLESv1_enc/gl_entry.cpp b/opengl/system/GLESv1_enc/gl_entry.cpp
index ecc13f4..2b7fa9f 100644
--- a/opengl/system/GLESv1_enc/gl_entry.cpp
+++ b/opengl/system/GLESv1_enc/gl_entry.cpp
@@ -267,7 +267,7 @@ extern "C" {
 	GLboolean glIsVertexArrayOES(GLuint array);
 	void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments);
 	void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount);
-	void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid*const* indices, GLsizei primcount);
+	void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount);
 	void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount);
 	void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount);
 	void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
@@ -303,1764 +303,1764 @@ extern "C" {
 #ifndef GET_CONTEXT
 static gl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
 void gl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
-#define GET_CONTEXT gl_client_context_t * ctx = getCurrentContext() 
+#define GET_CONTEXT gl_client_context_t * ctx = getCurrentContext()
 #endif
 
 void glAlphaFunc(GLenum func, GLclampf ref)
 {
-	GET_CONTEXT; 
-	 ctx->glAlphaFunc(ctx, func, ref);
+	GET_CONTEXT;
+	ctx->glAlphaFunc(ctx, func, ref);
 }
 
 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glClearColor(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glClearColor(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthf(GLclampf depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthf(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthf(ctx, depth);
 }
 
 void glClipPlanef(GLenum plane, const GLfloat* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanef(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanef(ctx, plane, equation);
 }
 
 void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4f(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4f(ctx, red, green, blue, alpha);
 }
 
 void glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangef(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangef(ctx, zNear, zFar);
 }
 
 void glFogf(GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glFogf(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glFogf(ctx, pname, param);
 }
 
 void glFogfv(GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glFogfv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glFogfv(ctx, pname, params);
 }
 
 void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumf(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumf(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glGetClipPlanef(GLenum pname, GLfloat* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanef(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanef(ctx, pname, eqn);
 }
 
 void glGetFloatv(GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFloatv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFloatv(ctx, pname, params);
 }
 
 void glGetLightfv(GLenum light, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetLightfv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glGetLightfv(ctx, light, pname, params);
 }
 
 void glGetMaterialfv(GLenum face, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetMaterialfv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glGetMaterialfv(ctx, face, pname, params);
 }
 
 void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnvfv(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnvfv(ctx, env, pname, params);
 }
 
 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameterfv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameterfv(ctx, target, pname, params);
 }
 
 void glLightModelf(GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelf(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glLightModelf(ctx, pname, param);
 }
 
 void glLightModelfv(GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelfv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glLightModelfv(ctx, pname, params);
 }
 
 void glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightf(ctx, light, pname, param);
+	GET_CONTEXT;
+	ctx->glLightf(ctx, light, pname, param);
 }
 
 void glLightfv(GLenum light, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightfv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glLightfv(ctx, light, pname, params);
 }
 
 void glLineWidth(GLfloat width)
 {
-	GET_CONTEXT; 
-	 ctx->glLineWidth(ctx, width);
+	GET_CONTEXT;
+	ctx->glLineWidth(ctx, width);
 }
 
 void glLoadMatrixf(const GLfloat* m)
 {
-	GET_CONTEXT; 
-	 ctx->glLoadMatrixf(ctx, m);
+	GET_CONTEXT;
+	ctx->glLoadMatrixf(ctx, m);
 }
 
 void glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialf(ctx, face, pname, param);
+	GET_CONTEXT;
+	ctx->glMaterialf(ctx, face, pname, param);
 }
 
 void glMaterialfv(GLenum face, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialfv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glMaterialfv(ctx, face, pname, params);
 }
 
 void glMultMatrixf(const GLfloat* m)
 {
-	GET_CONTEXT; 
-	 ctx->glMultMatrixf(ctx, m);
+	GET_CONTEXT;
+	ctx->glMultMatrixf(ctx, m);
 }
 
 void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiTexCoord4f(ctx, target, s, t, r, q);
+	GET_CONTEXT;
+	ctx->glMultiTexCoord4f(ctx, target, s, t, r, q);
 }
 
 void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-	GET_CONTEXT; 
-	 ctx->glNormal3f(ctx, nx, ny, nz);
+	GET_CONTEXT;
+	ctx->glNormal3f(ctx, nx, ny, nz);
 }
 
 void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthof(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthof(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glPointParameterf(GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterf(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPointParameterf(ctx, pname, param);
 }
 
 void glPointParameterfv(GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterfv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glPointParameterfv(ctx, pname, params);
 }
 
 void glPointSize(GLfloat size)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSize(ctx, size);
+	GET_CONTEXT;
+	ctx->glPointSize(ctx, size);
 }
 
 void glPolygonOffset(GLfloat factor, GLfloat units)
 {
-	GET_CONTEXT; 
-	 ctx->glPolygonOffset(ctx, factor, units);
+	GET_CONTEXT;
+	ctx->glPolygonOffset(ctx, factor, units);
 }
 
 void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
-	 ctx->glRotatef(ctx, angle, x, y, z);
+	GET_CONTEXT;
+	ctx->glRotatef(ctx, angle, x, y, z);
 }
 
 void glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
-	 ctx->glScalef(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glScalef(ctx, x, y, z);
 }
 
 void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvf(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvf(ctx, target, pname, param);
 }
 
 void glTexEnvfv(GLenum target, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvfv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnvfv(ctx, target, pname, params);
 }
 
 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterf(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameterf(ctx, target, pname, param);
 }
 
 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterfv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameterfv(ctx, target, pname, params);
 }
 
 void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-	GET_CONTEXT; 
-	 ctx->glTranslatef(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glTranslatef(ctx, x, y, z);
 }
 
 void glActiveTexture(GLenum texture)
 {
-	GET_CONTEXT; 
-	 ctx->glActiveTexture(ctx, texture);
+	GET_CONTEXT;
+	ctx->glActiveTexture(ctx, texture);
 }
 
 void glAlphaFuncx(GLenum func, GLclampx ref)
 {
-	GET_CONTEXT; 
-	 ctx->glAlphaFuncx(ctx, func, ref);
+	GET_CONTEXT;
+	ctx->glAlphaFuncx(ctx, func, ref);
 }
 
 void glBindBuffer(GLenum target, GLuint buffer)
 {
-	GET_CONTEXT; 
-	 ctx->glBindBuffer(ctx, target, buffer);
+	GET_CONTEXT;
+	ctx->glBindBuffer(ctx, target, buffer);
 }
 
 void glBindTexture(GLenum target, GLuint texture)
 {
-	GET_CONTEXT; 
-	 ctx->glBindTexture(ctx, target, texture);
+	GET_CONTEXT;
+	ctx->glBindTexture(ctx, target, texture);
 }
 
 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendFunc(ctx, sfactor, dfactor);
+	GET_CONTEXT;
+	ctx->glBlendFunc(ctx, sfactor, dfactor);
 }
 
 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 {
-	GET_CONTEXT; 
-	 ctx->glBufferData(ctx, target, size, data, usage);
+	GET_CONTEXT;
+	ctx->glBufferData(ctx, target, size, data, usage);
 }
 
 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 {
-	GET_CONTEXT; 
-	 ctx->glBufferSubData(ctx, target, offset, size, data);
+	GET_CONTEXT;
+	ctx->glBufferSubData(ctx, target, offset, size, data);
 }
 
 void glClear(GLbitfield mask)
 {
-	GET_CONTEXT; 
-	 ctx->glClear(ctx, mask);
+	GET_CONTEXT;
+	ctx->glClear(ctx, mask);
 }
 
 void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glClearColorx(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glClearColorx(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthx(GLclampx depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthx(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthx(ctx, depth);
 }
 
 void glClearStencil(GLint s)
 {
-	GET_CONTEXT; 
-	 ctx->glClearStencil(ctx, s);
+	GET_CONTEXT;
+	ctx->glClearStencil(ctx, s);
 }
 
 void glClientActiveTexture(GLenum texture)
 {
-	GET_CONTEXT; 
-	 ctx->glClientActiveTexture(ctx, texture);
+	GET_CONTEXT;
+	ctx->glClientActiveTexture(ctx, texture);
 }
 
 void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4ub(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4ub(ctx, red, green, blue, alpha);
 }
 
 void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4x(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4x(ctx, red, green, blue, alpha);
 }
 
 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColorMask(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColorMask(ctx, red, green, blue, alpha);
 }
 
 void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glColorPointer(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glColorPointer(ctx, size, type, stride, pointer);
 }
 
 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
-	 ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
+	GET_CONTEXT;
+	ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
 }
 
 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
-	GET_CONTEXT; 
-	 ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
+	GET_CONTEXT;
+	ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-	GET_CONTEXT; 
-	 ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
+	GET_CONTEXT;
+	ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
 }
 
 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
+	GET_CONTEXT;
+	ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
 }
 
 void glCullFace(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glCullFace(ctx, mode);
+	GET_CONTEXT;
+	ctx->glCullFace(ctx, mode);
 }
 
 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteBuffers(ctx, n, buffers);
+	ctx->glDeleteBuffers(ctx, n, buffers);
 }
 
 void glDeleteTextures(GLsizei n, const GLuint* textures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteTextures(ctx, n, textures);
+	ctx->glDeleteTextures(ctx, n, textures);
 }
 
 void glDepthFunc(GLenum func)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthFunc(ctx, func);
+	GET_CONTEXT;
+	ctx->glDepthFunc(ctx, func);
 }
 
 void glDepthMask(GLboolean flag)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthMask(ctx, flag);
+	GET_CONTEXT;
+	ctx->glDepthMask(ctx, flag);
 }
 
 void glDepthRangex(GLclampx zNear, GLclampx zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangex(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangex(ctx, zNear, zFar);
 }
 
 void glDisable(GLenum cap)
 {
-	GET_CONTEXT; 
-	 ctx->glDisable(ctx, cap);
+	GET_CONTEXT;
+	ctx->glDisable(ctx, cap);
 }
 
 void glDisableClientState(GLenum array)
 {
-	GET_CONTEXT; 
-	 ctx->glDisableClientState(ctx, array);
+	GET_CONTEXT;
+	ctx->glDisableClientState(ctx, array);
 }
 
 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawArrays(ctx, mode, first, count);
+	GET_CONTEXT;
+	ctx->glDrawArrays(ctx, mode, first, count);
 }
 
 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawElements(ctx, mode, count, type, indices);
+	GET_CONTEXT;
+	ctx->glDrawElements(ctx, mode, count, type, indices);
 }
 
 void glEnable(GLenum cap)
 {
-	GET_CONTEXT; 
-	 ctx->glEnable(ctx, cap);
+	GET_CONTEXT;
+	ctx->glEnable(ctx, cap);
 }
 
 void glEnableClientState(GLenum array)
 {
-	GET_CONTEXT; 
-	 ctx->glEnableClientState(ctx, array);
+	GET_CONTEXT;
+	ctx->glEnableClientState(ctx, array);
 }
 
 void glFinish()
 {
-	GET_CONTEXT; 
-	 ctx->glFinish(ctx);
+	GET_CONTEXT;
+	ctx->glFinish(ctx);
 }
 
 void glFlush()
 {
-	GET_CONTEXT; 
-	 ctx->glFlush(ctx);
+	GET_CONTEXT;
+	ctx->glFlush(ctx);
 }
 
 void glFogx(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glFogx(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glFogx(ctx, pname, param);
 }
 
 void glFogxv(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glFogxv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glFogxv(ctx, pname, params);
 }
 
 void glFrontFace(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glFrontFace(ctx, mode);
+	GET_CONTEXT;
+	ctx->glFrontFace(ctx, mode);
 }
 
 void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumx(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumx(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glGetBooleanv(GLenum pname, GLboolean* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetBooleanv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetBooleanv(ctx, pname, params);
 }
 
 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetBufferParameteriv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetBufferParameteriv(ctx, target, pname, params);
 }
 
 void glClipPlanex(GLenum pname, const GLfixed* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanex(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glClipPlanex(ctx, pname, eqn);
 }
 
 void glGenBuffers(GLsizei n, GLuint* buffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenBuffers(ctx, n, buffers);
+	ctx->glGenBuffers(ctx, n, buffers);
 }
 
 void glGenTextures(GLsizei n, GLuint* textures)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenTextures(ctx, n, textures);
+	ctx->glGenTextures(ctx, n, textures);
 }
 
 GLenum glGetError()
 {
-	GET_CONTEXT; 
-	 return ctx->glGetError(ctx);
+	GET_CONTEXT;
+	return ctx->glGetError(ctx);
 }
 
 void glGetFixedv(GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFixedv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFixedv(ctx, pname, params);
 }
 
 void glGetIntegerv(GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetIntegerv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetIntegerv(ctx, pname, params);
 }
 
 void glGetLightxv(GLenum light, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetLightxv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glGetLightxv(ctx, light, pname, params);
 }
 
 void glGetMaterialxv(GLenum face, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetMaterialxv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glGetMaterialxv(ctx, face, pname, params);
 }
 
 void glGetPointerv(GLenum pname, GLvoid** params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetPointerv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetPointerv(ctx, pname, params);
 }
 
 const GLubyte* glGetString(GLenum name)
 {
-	GET_CONTEXT; 
-	 return ctx->glGetString(ctx, name);
+	GET_CONTEXT;
+	return ctx->glGetString(ctx, name);
 }
 
 void glGetTexEnviv(GLenum env, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnviv(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnviv(ctx, env, pname, params);
 }
 
 void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnvxv(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnvxv(ctx, env, pname, params);
 }
 
 void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameteriv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameteriv(ctx, target, pname, params);
 }
 
 void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameterxv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameterxv(ctx, target, pname, params);
 }
 
 void glHint(GLenum target, GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glHint(ctx, target, mode);
+	GET_CONTEXT;
+	ctx->glHint(ctx, target, mode);
 }
 
 GLboolean glIsBuffer(GLuint buffer)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsBuffer(ctx, buffer);
+	GET_CONTEXT;
+	return ctx->glIsBuffer(ctx, buffer);
 }
 
 GLboolean glIsEnabled(GLenum cap)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsEnabled(ctx, cap);
+	GET_CONTEXT;
+	return ctx->glIsEnabled(ctx, cap);
 }
 
 GLboolean glIsTexture(GLuint texture)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsTexture(ctx, texture);
+	GET_CONTEXT;
+	return ctx->glIsTexture(ctx, texture);
 }
 
 void glLightModelx(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelx(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glLightModelx(ctx, pname, param);
 }
 
 void glLightModelxv(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelxv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glLightModelxv(ctx, pname, params);
 }
 
 void glLightx(GLenum light, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightx(ctx, light, pname, param);
+	GET_CONTEXT;
+	ctx->glLightx(ctx, light, pname, param);
 }
 
 void glLightxv(GLenum light, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightxv(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glLightxv(ctx, light, pname, params);
 }
 
 void glLineWidthx(GLfixed width)
 {
-	GET_CONTEXT; 
-	 ctx->glLineWidthx(ctx, width);
+	GET_CONTEXT;
+	ctx->glLineWidthx(ctx, width);
 }
 
 void glLoadIdentity()
 {
-	GET_CONTEXT; 
-	 ctx->glLoadIdentity(ctx);
+	GET_CONTEXT;
+	ctx->glLoadIdentity(ctx);
 }
 
 void glLoadMatrixx(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glLoadMatrixx(ctx, m);
+	GET_CONTEXT;
+	ctx->glLoadMatrixx(ctx, m);
 }
 
 void glLogicOp(GLenum opcode)
 {
-	GET_CONTEXT; 
-	 ctx->glLogicOp(ctx, opcode);
+	GET_CONTEXT;
+	ctx->glLogicOp(ctx, opcode);
 }
 
 void glMaterialx(GLenum face, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialx(ctx, face, pname, param);
+	GET_CONTEXT;
+	ctx->glMaterialx(ctx, face, pname, param);
 }
 
 void glMaterialxv(GLenum face, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialxv(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glMaterialxv(ctx, face, pname, params);
 }
 
 void glMatrixMode(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixMode(ctx, mode);
+	GET_CONTEXT;
+	ctx->glMatrixMode(ctx, mode);
 }
 
 void glMultMatrixx(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glMultMatrixx(ctx, m);
+	GET_CONTEXT;
+	ctx->glMultMatrixx(ctx, m);
 }
 
 void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiTexCoord4x(ctx, target, s, t, r, q);
+	GET_CONTEXT;
+	ctx->glMultiTexCoord4x(ctx, target, s, t, r, q);
 }
 
 void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
 {
-	GET_CONTEXT; 
-	 ctx->glNormal3x(ctx, nx, ny, nz);
+	GET_CONTEXT;
+	ctx->glNormal3x(ctx, nx, ny, nz);
 }
 
 void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glNormalPointer(ctx, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glNormalPointer(ctx, type, stride, pointer);
 }
 
 void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthox(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthox(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glPixelStorei(GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glPixelStorei(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPixelStorei(ctx, pname, param);
 }
 
 void glPointParameterx(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterx(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPointParameterx(ctx, pname, param);
 }
 
 void glPointParameterxv(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterxv(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glPointParameterxv(ctx, pname, params);
 }
 
 void glPointSizex(GLfixed size)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizex(ctx, size);
+	GET_CONTEXT;
+	ctx->glPointSizex(ctx, size);
 }
 
 void glPolygonOffsetx(GLfixed factor, GLfixed units)
 {
-	GET_CONTEXT; 
-	 ctx->glPolygonOffsetx(ctx, factor, units);
+	GET_CONTEXT;
+	ctx->glPolygonOffsetx(ctx, factor, units);
 }
 
 void glPopMatrix()
 {
-	GET_CONTEXT; 
-	 ctx->glPopMatrix(ctx);
+	GET_CONTEXT;
+	ctx->glPopMatrix(ctx);
 }
 
 void glPushMatrix()
 {
-	GET_CONTEXT; 
-	 ctx->glPushMatrix(ctx);
+	GET_CONTEXT;
+	ctx->glPushMatrix(ctx);
 }
 
 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
+	GET_CONTEXT;
+	ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
 }
 
 void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glRotatex(ctx, angle, x, y, z);
+	GET_CONTEXT;
+	ctx->glRotatex(ctx, angle, x, y, z);
 }
 
 void glSampleCoverage(GLclampf value, GLboolean invert)
 {
-	GET_CONTEXT; 
-	 ctx->glSampleCoverage(ctx, value, invert);
+	GET_CONTEXT;
+	ctx->glSampleCoverage(ctx, value, invert);
 }
 
 void glSampleCoveragex(GLclampx value, GLboolean invert)
 {
-	GET_CONTEXT; 
-	 ctx->glSampleCoveragex(ctx, value, invert);
+	GET_CONTEXT;
+	ctx->glSampleCoveragex(ctx, value, invert);
 }
 
 void glScalex(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glScalex(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glScalex(ctx, x, y, z);
 }
 
 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glScissor(ctx, x, y, width, height);
+	GET_CONTEXT;
+	ctx->glScissor(ctx, x, y, width, height);
 }
 
 void glShadeModel(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glShadeModel(ctx, mode);
+	GET_CONTEXT;
+	ctx->glShadeModel(ctx, mode);
 }
 
 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-	GET_CONTEXT; 
-	 ctx->glStencilFunc(ctx, func, ref, mask);
+	GET_CONTEXT;
+	ctx->glStencilFunc(ctx, func, ref, mask);
 }
 
 void glStencilMask(GLuint mask)
 {
-	GET_CONTEXT; 
-	 ctx->glStencilMask(ctx, mask);
+	GET_CONTEXT;
+	ctx->glStencilMask(ctx, mask);
 }
 
 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-	GET_CONTEXT; 
-	 ctx->glStencilOp(ctx, fail, zfail, zpass);
+	GET_CONTEXT;
+	ctx->glStencilOp(ctx, fail, zfail, zpass);
 }
 
 void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glTexCoordPointer(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glTexCoordPointer(ctx, size, type, stride, pointer);
 }
 
 void glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvi(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvi(ctx, target, pname, param);
 }
 
 void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvx(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvx(ctx, target, pname, param);
 }
 
 void glTexEnviv(GLenum target, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnviv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnviv(ctx, target, pname, params);
 }
 
 void glTexEnvxv(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvxv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnvxv(ctx, target, pname, params);
 }
 
 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
+	GET_CONTEXT;
+	ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 void glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameteri(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameteri(ctx, target, pname, param);
 }
 
 void glTexParameterx(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterx(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameterx(ctx, target, pname, param);
 }
 
 void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameteriv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameteriv(ctx, target, pname, params);
 }
 
 void glTexParameterxv(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterxv(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameterxv(ctx, target, pname, params);
 }
 
 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
+	GET_CONTEXT;
+	ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glTranslatex(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glTranslatex(ctx, x, y, z);
 }
 
 void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glVertexPointer(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glVertexPointer(ctx, size, type, stride, pointer);
 }
 
 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glViewport(ctx, x, y, width, height);
+	GET_CONTEXT;
+	ctx->glViewport(ctx, x, y, width, height);
 }
 
 void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizePointerOES(ctx, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glPointSizePointerOES(ctx, type, stride, pointer);
 }
 
 void glVertexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glVertexPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glVertexPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glColorPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glColorPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glColorPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glNormalPointerOffset(GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glNormalPointerOffset(ctx, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glNormalPointerOffset(ctx, type, stride, offset);
 }
 
 void glPointSizePointerOffset(GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizePointerOffset(ctx, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glPointSizePointerOffset(ctx, type, stride, offset);
 }
 
 void glTexCoordPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glTexCoordPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glTexCoordPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glWeightPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glWeightPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glWeightPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glMatrixIndexPointerOffset(GLint size, GLenum type, GLsizei stride, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixIndexPointerOffset(ctx, size, type, stride, offset);
+	GET_CONTEXT;
+	ctx->glMatrixIndexPointerOffset(ctx, size, type, stride, offset);
 }
 
 void glVertexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glVertexPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glVertexPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glColorPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glColorPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glColorPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glNormalPointerData(GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glNormalPointerData(ctx, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glNormalPointerData(ctx, type, stride, data, datalen);
 }
 
 void glTexCoordPointerData(GLint unit, GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glTexCoordPointerData(ctx, unit, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glTexCoordPointerData(ctx, unit, size, type, stride, data, datalen);
 }
 
 void glPointSizePointerData(GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizePointerData(ctx, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glPointSizePointerData(ctx, type, stride, data, datalen);
 }
 
 void glWeightPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glWeightPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glWeightPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glMatrixIndexPointerData(GLint size, GLenum type, GLsizei stride, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixIndexPointerData(ctx, size, type, stride, data, datalen);
+	GET_CONTEXT;
+	ctx->glMatrixIndexPointerData(ctx, size, type, stride, data, datalen);
 }
 
 void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
+	GET_CONTEXT;
+	ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
 }
 
 void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
+	GET_CONTEXT;
+	ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
 }
 
 void glGetCompressedTextureFormats(int count, GLint* formats)
 {
-	GET_CONTEXT; 
-	 ctx->glGetCompressedTextureFormats(ctx, count, formats);
+	GET_CONTEXT;
+	ctx->glGetCompressedTextureFormats(ctx, count, formats);
 }
 
 int glFinishRoundTrip()
 {
-	GET_CONTEXT; 
-	 return ctx->glFinishRoundTrip(ctx);
+	GET_CONTEXT;
+	return ctx->glFinishRoundTrip(ctx);
 }
 
 void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendEquationSeparateOES(ctx, modeRGB, modeAlpha);
+	GET_CONTEXT;
+	ctx->glBlendEquationSeparateOES(ctx, modeRGB, modeAlpha);
 }
 
 void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendFuncSeparateOES(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
+	GET_CONTEXT;
+	ctx->glBlendFuncSeparateOES(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void glBlendEquationOES(GLenum mode)
 {
-	GET_CONTEXT; 
-	 ctx->glBlendEquationOES(ctx, mode);
+	GET_CONTEXT;
+	ctx->glBlendEquationOES(ctx, mode);
 }
 
 void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexsOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexsOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexiOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexiOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexxOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexxOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexsvOES(const GLshort* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexsvOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexsvOES(ctx, coords);
 }
 
 void glDrawTexivOES(const GLint* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexivOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexivOES(ctx, coords);
 }
 
 void glDrawTexxvOES(const GLfixed* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexxvOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexxvOES(ctx, coords);
 }
 
 void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexfOES(ctx, x, y, z, width, height);
+	GET_CONTEXT;
+	ctx->glDrawTexfOES(ctx, x, y, z, width, height);
 }
 
 void glDrawTexfvOES(const GLfloat* coords)
 {
-	GET_CONTEXT; 
-	 ctx->glDrawTexfvOES(ctx, coords);
+	GET_CONTEXT;
+	ctx->glDrawTexfvOES(ctx, coords);
 }
 
 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 {
-	GET_CONTEXT; 
-	 ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
+	GET_CONTEXT;
+	ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
 }
 
 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 {
-	GET_CONTEXT; 
-	 ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
+	GET_CONTEXT;
+	ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
 }
 
 void glAlphaFuncxOES(GLenum func, GLclampx ref)
 {
-	GET_CONTEXT; 
-	 ctx->glAlphaFuncxOES(ctx, func, ref);
+	GET_CONTEXT;
+	ctx->glAlphaFuncxOES(ctx, func, ref);
 }
 
 void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glClearColorxOES(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glClearColorxOES(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthxOES(GLclampx depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthxOES(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthxOES(ctx, depth);
 }
 
 void glClipPlanexOES(GLenum plane, const GLfixed* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanexOES(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanexOES(ctx, plane, equation);
 }
 
 void glClipPlanexIMG(GLenum plane, const GLfixed* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanexIMG(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanexIMG(ctx, plane, equation);
 }
 
 void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
 {
-	GET_CONTEXT; 
-	 ctx->glColor4xOES(ctx, red, green, blue, alpha);
+	GET_CONTEXT;
+	ctx->glColor4xOES(ctx, red, green, blue, alpha);
 }
 
 void glDepthRangexOES(GLclampx zNear, GLclampx zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangexOES(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangexOES(ctx, zNear, zFar);
 }
 
 void glFogxOES(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glFogxOES(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glFogxOES(ctx, pname, param);
 }
 
 void glFogxvOES(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glFogxvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glFogxvOES(ctx, pname, params);
 }
 
 void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumxOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumxOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glGetClipPlanexOES(GLenum pname, GLfixed* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanexOES(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanexOES(ctx, pname, eqn);
 }
 
 void glGetClipPlanex(GLenum pname, GLfixed* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanex(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanex(ctx, pname, eqn);
 }
 
 void glGetFixedvOES(GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFixedvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFixedvOES(ctx, pname, params);
 }
 
 void glGetLightxvOES(GLenum light, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetLightxvOES(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glGetLightxvOES(ctx, light, pname, params);
 }
 
 void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetMaterialxvOES(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glGetMaterialxvOES(ctx, face, pname, params);
 }
 
 void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexEnvxvOES(ctx, env, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexEnvxvOES(ctx, env, pname, params);
 }
 
 void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexParameterxvOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexParameterxvOES(ctx, target, pname, params);
 }
 
 void glLightModelxOES(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelxOES(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glLightModelxOES(ctx, pname, param);
 }
 
 void glLightModelxvOES(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightModelxvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glLightModelxvOES(ctx, pname, params);
 }
 
 void glLightxOES(GLenum light, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glLightxOES(ctx, light, pname, param);
+	GET_CONTEXT;
+	ctx->glLightxOES(ctx, light, pname, param);
 }
 
 void glLightxvOES(GLenum light, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glLightxvOES(ctx, light, pname, params);
+	GET_CONTEXT;
+	ctx->glLightxvOES(ctx, light, pname, params);
 }
 
 void glLineWidthxOES(GLfixed width)
 {
-	GET_CONTEXT; 
-	 ctx->glLineWidthxOES(ctx, width);
+	GET_CONTEXT;
+	ctx->glLineWidthxOES(ctx, width);
 }
 
 void glLoadMatrixxOES(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glLoadMatrixxOES(ctx, m);
+	GET_CONTEXT;
+	ctx->glLoadMatrixxOES(ctx, m);
 }
 
 void glMaterialxOES(GLenum face, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialxOES(ctx, face, pname, param);
+	GET_CONTEXT;
+	ctx->glMaterialxOES(ctx, face, pname, param);
 }
 
 void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glMaterialxvOES(ctx, face, pname, params);
+	GET_CONTEXT;
+	ctx->glMaterialxvOES(ctx, face, pname, params);
 }
 
 void glMultMatrixxOES(const GLfixed* m)
 {
-	GET_CONTEXT; 
-	 ctx->glMultMatrixxOES(ctx, m);
+	GET_CONTEXT;
+	ctx->glMultMatrixxOES(ctx, m);
 }
 
 void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiTexCoord4xOES(ctx, target, s, t, r, q);
+	GET_CONTEXT;
+	ctx->glMultiTexCoord4xOES(ctx, target, s, t, r, q);
 }
 
 void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
 {
-	GET_CONTEXT; 
-	 ctx->glNormal3xOES(ctx, nx, ny, nz);
+	GET_CONTEXT;
+	ctx->glNormal3xOES(ctx, nx, ny, nz);
 }
 
 void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthoxOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthoxOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glPointParameterxOES(GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterxOES(ctx, pname, param);
+	GET_CONTEXT;
+	ctx->glPointParameterxOES(ctx, pname, param);
 }
 
 void glPointParameterxvOES(GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glPointParameterxvOES(ctx, pname, params);
+	GET_CONTEXT;
+	ctx->glPointParameterxvOES(ctx, pname, params);
 }
 
 void glPointSizexOES(GLfixed size)
 {
-	GET_CONTEXT; 
-	 ctx->glPointSizexOES(ctx, size);
+	GET_CONTEXT;
+	ctx->glPointSizexOES(ctx, size);
 }
 
 void glPolygonOffsetxOES(GLfixed factor, GLfixed units)
 {
-	GET_CONTEXT; 
-	 ctx->glPolygonOffsetxOES(ctx, factor, units);
+	GET_CONTEXT;
+	ctx->glPolygonOffsetxOES(ctx, factor, units);
 }
 
 void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glRotatexOES(ctx, angle, x, y, z);
+	GET_CONTEXT;
+	ctx->glRotatexOES(ctx, angle, x, y, z);
 }
 
 void glSampleCoveragexOES(GLclampx value, GLboolean invert)
 {
-	GET_CONTEXT; 
-	 ctx->glSampleCoveragexOES(ctx, value, invert);
+	GET_CONTEXT;
+	ctx->glSampleCoveragexOES(ctx, value, invert);
 }
 
 void glScalexOES(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glScalexOES(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glScalexOES(ctx, x, y, z);
 }
 
 void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvxOES(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexEnvxOES(ctx, target, pname, param);
 }
 
 void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexEnvxvOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexEnvxvOES(ctx, target, pname, params);
 }
 
 void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterxOES(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glTexParameterxOES(ctx, target, pname, param);
 }
 
 void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexParameterxvOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glTexParameterxvOES(ctx, target, pname, params);
 }
 
 void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
 {
-	GET_CONTEXT; 
-	 ctx->glTranslatexOES(ctx, x, y, z);
+	GET_CONTEXT;
+	ctx->glTranslatexOES(ctx, x, y, z);
 }
 
 GLboolean glIsRenderbufferOES(GLuint renderbuffer)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsRenderbufferOES(ctx, renderbuffer);
+	GET_CONTEXT;
+	return ctx->glIsRenderbufferOES(ctx, renderbuffer);
 }
 
 void glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->glBindRenderbufferOES(ctx, target, renderbuffer);
+	GET_CONTEXT;
+	ctx->glBindRenderbufferOES(ctx, target, renderbuffer);
 }
 
 void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteRenderbuffersOES(ctx, n, renderbuffers);
+	ctx->glDeleteRenderbuffersOES(ctx, n, renderbuffers);
 }
 
 void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenRenderbuffersOES(ctx, n, renderbuffers);
+	ctx->glGenRenderbuffersOES(ctx, n, renderbuffers);
 }
 
 void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glRenderbufferStorageOES(ctx, target, internalformat, width, height);
+	GET_CONTEXT;
+	ctx->glRenderbufferStorageOES(ctx, target, internalformat, width, height);
 }
 
 void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetRenderbufferParameterivOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetRenderbufferParameterivOES(ctx, target, pname, params);
 }
 
 GLboolean glIsFramebufferOES(GLuint framebuffer)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsFramebufferOES(ctx, framebuffer);
+	GET_CONTEXT;
+	return ctx->glIsFramebufferOES(ctx, framebuffer);
 }
 
 void glBindFramebufferOES(GLenum target, GLuint framebuffer)
 {
-	GET_CONTEXT; 
-	 ctx->glBindFramebufferOES(ctx, target, framebuffer);
+	GET_CONTEXT;
+	ctx->glBindFramebufferOES(ctx, target, framebuffer);
 }
 
 void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteFramebuffersOES(ctx, n, framebuffers);
+	ctx->glDeleteFramebuffersOES(ctx, n, framebuffers);
 }
 
 void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenFramebuffersOES(ctx, n, framebuffers);
+	ctx->glGenFramebuffersOES(ctx, n, framebuffers);
 }
 
 GLenum glCheckFramebufferStatusOES(GLenum target)
 {
-	GET_CONTEXT; 
-	 return ctx->glCheckFramebufferStatusOES(ctx, target);
+	GET_CONTEXT;
+	return ctx->glCheckFramebufferStatusOES(ctx, target);
 }
 
 void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->glFramebufferRenderbufferOES(ctx, target, attachment, renderbuffertarget, renderbuffer);
+	GET_CONTEXT;
+	ctx->glFramebufferRenderbufferOES(ctx, target, attachment, renderbuffertarget, renderbuffer);
 }
 
 void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-	GET_CONTEXT; 
-	 ctx->glFramebufferTexture2DOES(ctx, target, attachment, textarget, texture, level);
+	GET_CONTEXT;
+	ctx->glFramebufferTexture2DOES(ctx, target, attachment, textarget, texture, level);
 }
 
 void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFramebufferAttachmentParameterivOES(ctx, target, attachment, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFramebufferAttachmentParameterivOES(ctx, target, attachment, pname, params);
 }
 
 void glGenerateMipmapOES(GLenum target)
 {
-	GET_CONTEXT; 
-	 ctx->glGenerateMipmapOES(ctx, target);
+	GET_CONTEXT;
+	ctx->glGenerateMipmapOES(ctx, target);
 }
 
 void* glMapBufferOES(GLenum target, GLenum access)
 {
-	GET_CONTEXT; 
-	 return ctx->glMapBufferOES(ctx, target, access);
+	GET_CONTEXT;
+	return ctx->glMapBufferOES(ctx, target, access);
 }
 
 GLboolean glUnmapBufferOES(GLenum target)
 {
-	GET_CONTEXT; 
-	 return ctx->glUnmapBufferOES(ctx, target);
+	GET_CONTEXT;
+	return ctx->glUnmapBufferOES(ctx, target);
 }
 
 void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid** params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetBufferPointervOES(ctx, target, pname, params);
+	GET_CONTEXT;
+	ctx->glGetBufferPointervOES(ctx, target, pname, params);
 }
 
 void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
 {
-	GET_CONTEXT; 
-	 ctx->glCurrentPaletteMatrixOES(ctx, matrixpaletteindex);
+	GET_CONTEXT;
+	ctx->glCurrentPaletteMatrixOES(ctx, matrixpaletteindex);
 }
 
 void glLoadPaletteFromModelViewMatrixOES()
 {
-	GET_CONTEXT; 
-	 ctx->glLoadPaletteFromModelViewMatrixOES(ctx);
+	GET_CONTEXT;
+	ctx->glLoadPaletteFromModelViewMatrixOES(ctx);
 }
 
 void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glMatrixIndexPointerOES(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glMatrixIndexPointerOES(ctx, size, type, stride, pointer);
 }
 
 void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
 {
-	GET_CONTEXT; 
-	 ctx->glWeightPointerOES(ctx, size, type, stride, pointer);
+	GET_CONTEXT;
+	ctx->glWeightPointerOES(ctx, size, type, stride, pointer);
 }
 
 GLbitfield glQueryMatrixxOES(GLfixed* mantissa, GLint* exponent)
 {
-	GET_CONTEXT; 
-	 return ctx->glQueryMatrixxOES(ctx, mantissa, exponent);
+	GET_CONTEXT;
+	return ctx->glQueryMatrixxOES(ctx, mantissa, exponent);
 }
 
 void glDepthRangefOES(GLclampf zNear, GLclampf zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glDepthRangefOES(ctx, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glDepthRangefOES(ctx, zNear, zFar);
 }
 
 void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glFrustumfOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glFrustumfOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
 {
-	GET_CONTEXT; 
-	 ctx->glOrthofOES(ctx, left, right, bottom, top, zNear, zFar);
+	GET_CONTEXT;
+	ctx->glOrthofOES(ctx, left, right, bottom, top, zNear, zFar);
 }
 
 void glClipPlanefOES(GLenum plane, const GLfloat* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanefOES(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanefOES(ctx, plane, equation);
 }
 
 void glClipPlanefIMG(GLenum plane, const GLfloat* equation)
 {
-	GET_CONTEXT; 
-	 ctx->glClipPlanefIMG(ctx, plane, equation);
+	GET_CONTEXT;
+	ctx->glClipPlanefIMG(ctx, plane, equation);
 }
 
 void glGetClipPlanefOES(GLenum pname, GLfloat* eqn)
 {
-	GET_CONTEXT; 
-	 ctx->glGetClipPlanefOES(ctx, pname, eqn);
+	GET_CONTEXT;
+	ctx->glGetClipPlanefOES(ctx, pname, eqn);
 }
 
 void glClearDepthfOES(GLclampf depth)
 {
-	GET_CONTEXT; 
-	 ctx->glClearDepthfOES(ctx, depth);
+	GET_CONTEXT;
+	ctx->glClearDepthfOES(ctx, depth);
 }
 
 void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenfOES(ctx, coord, pname, param);
+	GET_CONTEXT;
+	ctx->glTexGenfOES(ctx, coord, pname, param);
 }
 
 void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenfvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glTexGenfvOES(ctx, coord, pname, params);
 }
 
 void glTexGeniOES(GLenum coord, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGeniOES(ctx, coord, pname, param);
+	GET_CONTEXT;
+	ctx->glTexGeniOES(ctx, coord, pname, param);
 }
 
 void glTexGenivOES(GLenum coord, GLenum pname, const GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenivOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glTexGenivOES(ctx, coord, pname, params);
 }
 
 void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenxOES(ctx, coord, pname, param);
+	GET_CONTEXT;
+	ctx->glTexGenxOES(ctx, coord, pname, param);
 }
 
 void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glTexGenxvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glTexGenxvOES(ctx, coord, pname, params);
 }
 
 void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexGenfvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexGenfvOES(ctx, coord, pname, params);
 }
 
 void glGetTexGenivOES(GLenum coord, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexGenivOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexGenivOES(ctx, coord, pname, params);
 }
 
 void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetTexGenxvOES(ctx, coord, pname, params);
+	GET_CONTEXT;
+	ctx->glGetTexGenxvOES(ctx, coord, pname, params);
 }
 
 void glBindVertexArrayOES(GLuint array)
 {
-	GET_CONTEXT; 
-	 ctx->glBindVertexArrayOES(ctx, array);
+	GET_CONTEXT;
+	ctx->glBindVertexArrayOES(ctx, array);
 }
 
 void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteVertexArraysOES(ctx, n, arrays);
+	ctx->glDeleteVertexArraysOES(ctx, n, arrays);
 }
 
 void glGenVertexArraysOES(GLsizei n, GLuint* arrays)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenVertexArraysOES(ctx, n, arrays);
+	ctx->glGenVertexArraysOES(ctx, n, arrays);
 }
 
 GLboolean glIsVertexArrayOES(GLuint array)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsVertexArrayOES(ctx, array);
+	GET_CONTEXT;
+	return ctx->glIsVertexArrayOES(ctx, array);
 }
 
 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
 {
-	GET_CONTEXT; 
-	 ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
+	GET_CONTEXT;
+	ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
 }
 
 void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
 }
 
 void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
 }
 
 void glMultiDrawArraysSUN(GLenum mode, GLint* first, GLsizei* count, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawArraysSUN(ctx, mode, first, count, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawArraysSUN(ctx, mode, first, count, primcount);
 }
 
 void glMultiDrawElementsSUN(GLenum mode, const GLsizei* count, GLenum type, const GLvoid** indices, GLsizei primcount)
 {
-	GET_CONTEXT; 
-	 ctx->glMultiDrawElementsSUN(ctx, mode, count, type, indices, primcount);
+	GET_CONTEXT;
+	ctx->glMultiDrawElementsSUN(ctx, mode, count, type, indices, primcount);
 }
 
 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-	GET_CONTEXT; 
-	 ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
+	GET_CONTEXT;
+	ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
 }
 
 void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 {
-	GET_CONTEXT; 
-	 ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
+	GET_CONTEXT;
+	ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
 }
 
 void glDeleteFencesNV(GLsizei n, const GLuint* fences)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteFencesNV(ctx, n, fences);
+	ctx->glDeleteFencesNV(ctx, n, fences);
 }
 
 void glGenFencesNV(GLsizei n, GLuint* fences)
 {
-	GET_CONTEXT; 
+	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenFencesNV(ctx, n, fences);
+	ctx->glGenFencesNV(ctx, n, fences);
 }
 
 GLboolean glIsFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
-	 return ctx->glIsFenceNV(ctx, fence);
+	GET_CONTEXT;
+	return ctx->glIsFenceNV(ctx, fence);
 }
 
 GLboolean glTestFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
-	 return ctx->glTestFenceNV(ctx, fence);
+	GET_CONTEXT;
+	return ctx->glTestFenceNV(ctx, fence);
 }
 
 void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glGetFenceivNV(ctx, fence, pname, params);
+	GET_CONTEXT;
+	ctx->glGetFenceivNV(ctx, fence, pname, params);
 }
 
 void glFinishFenceNV(GLuint fence)
 {
-	GET_CONTEXT; 
-	 ctx->glFinishFenceNV(ctx, fence);
+	GET_CONTEXT;
+	ctx->glFinishFenceNV(ctx, fence);
 }
 
 void glSetFenceNV(GLuint fence, GLenum condition)
 {
-	GET_CONTEXT; 
-	 ctx->glSetFenceNV(ctx, fence, condition);
+	GET_CONTEXT;
+	ctx->glSetFenceNV(ctx, fence, condition);
 }
 
 void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls)
 {
-	GET_CONTEXT; 
-	 ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
+	GET_CONTEXT;
+	ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
 }
 
 void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString)
 {
-	GET_CONTEXT; 
-	 ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
+	GET_CONTEXT;
+	ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
 }
 
 void glEnableDriverControlQCOM(GLuint driverControl)
 {
-	GET_CONTEXT; 
-	 ctx->glEnableDriverControlQCOM(ctx, driverControl);
+	GET_CONTEXT;
+	ctx->glEnableDriverControlQCOM(ctx, driverControl);
 }
 
 void glDisableDriverControlQCOM(GLuint driverControl)
 {
-	GET_CONTEXT; 
-	 ctx->glDisableDriverControlQCOM(ctx, driverControl);
+	GET_CONTEXT;
+	ctx->glDisableDriverControlQCOM(ctx, driverControl);
 }
 
 void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
+	GET_CONTEXT;
+	ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
 }
 
 void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
+	GET_CONTEXT;
+	ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
 }
 
 void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
+	GET_CONTEXT;
+	ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
 }
 
 void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
+	GET_CONTEXT;
+	ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
 }
 
 void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
+	GET_CONTEXT;
+	ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
 }
 
 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
 {
-	GET_CONTEXT; 
-	 ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
+	GET_CONTEXT;
+	ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
 }
 
 void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
+	GET_CONTEXT;
+	ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
 }
 
 void glExtGetBufferPointervQCOM(GLenum target, GLvoid** params)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetBufferPointervQCOM(ctx, target, params);
+	GET_CONTEXT;
+	ctx->glExtGetBufferPointervQCOM(ctx, target, params);
 }
 
 void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
+	GET_CONTEXT;
+	ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
 }
 
 void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
+	GET_CONTEXT;
+	ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
 }
 
 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
 {
-	GET_CONTEXT; 
-	 return ctx->glExtIsProgramBinaryQCOM(ctx, program);
+	GET_CONTEXT;
+	return ctx->glExtIsProgramBinaryQCOM(ctx, program);
 }
 
 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length)
 {
-	GET_CONTEXT; 
-	 ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
+	GET_CONTEXT;
+	ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
 }
 
 void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
 {
-	GET_CONTEXT; 
-	 ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
+	GET_CONTEXT;
+	ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
 }
 
 void glEndTilingQCOM(GLbitfield preserveMask)
 {
-	GET_CONTEXT; 
-	 ctx->glEndTilingQCOM(ctx, preserveMask);
+	GET_CONTEXT;
+	ctx->glEndTilingQCOM(ctx, preserveMask);
 }
 
diff --git a/opengl/system/GLESv1_enc/gl_ftable.h b/opengl/system/GLESv1_enc/gl_ftable.h
index 7201e7f..67ba6f4 100644
--- a/opengl/system/GLESv1_enc/gl_ftable.h
+++ b/opengl/system/GLESv1_enc/gl_ftable.h
@@ -4,7 +4,7 @@
 #define __gl_client_ftable_t_h
 
 
-static struct _gl_funcs_by_name {
+static const struct _gl_funcs_by_name {
 	const char *name;
 	void *proc;
 } gl_funcs_by_name[] = {
@@ -282,7 +282,7 @@ static struct _gl_funcs_by_name {
 	{"glStartTilingQCOM", (void*)glStartTilingQCOM},
 	{"glEndTilingQCOM", (void*)glEndTilingQCOM},
 };
-static int gl_num_funcs = sizeof(gl_funcs_by_name) / sizeof(struct _gl_funcs_by_name);
+static const int gl_num_funcs = sizeof(gl_funcs_by_name) / sizeof(struct _gl_funcs_by_name);
 
 
 #endif
diff --git a/opengl/system/GLESv2/gl2.cpp b/opengl/system/GLESv2/gl2.cpp
index b32dd74..e545779 100644
--- a/opengl/system/GLESv2/gl2.cpp
+++ b/opengl/system/GLESv2/gl2.cpp
@@ -50,6 +50,9 @@ static EGLClient_glesInterface * s_gl = NULL;
 //GL extensions
 void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES image)
 {
+    (void)self;
+    (void)target;
+
     DBG("glEGLImageTargetTexture2DOES v2 target=%#x img=%p\n", target, image);
     //TODO: check error - we don't have a way to set gl error
     android_native_buffer_t* native_buffer = (android_native_buffer_t*)image;
@@ -74,6 +77,9 @@ void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES imag
 
 void glEGLImageTargetRenderbufferStorageOES(void *self, GLenum target, GLeglImageOES image)
 {
+    (void)self;
+    (void)target;
+
     DBG("glEGLImageTargetRenderbufferStorageOES v2 image=%p\n", image);
     //TODO: check error - we don't have a way to set gl error
     android_native_buffer_t* native_buffer = (android_native_buffer_t*)image;
@@ -110,6 +116,8 @@ void finish()
 
 const GLubyte *my_glGetString (void *self, GLenum name)
 {
+    (void)self;
+
     if (s_egl) {
         return (const GLubyte*)s_egl->getGLString(name);
     }
@@ -119,9 +127,9 @@ const GLubyte *my_glGetString (void *self, GLenum name)
 void init()
 {
     GET_CONTEXT;
-    ctx->set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES);
-    ctx->set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES);
-    ctx->set_glGetString(my_glGetString);
+    ctx->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES;
+    ctx->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES;
+    ctx->glGetString = &my_glGetString;
 }
 
 extern "C" {
diff --git a/opengl/system/GLESv2_enc/GL2Encoder.cpp b/opengl/system/GLESv2_enc/GL2Encoder.cpp
index f6f61e6..80a2cda 100644
--- a/opengl/system/GLESv2_enc/GL2Encoder.cpp
+++ b/opengl/system/GLESv2_enc/GL2Encoder.cpp
@@ -48,74 +48,80 @@ GL2Encoder::GL2Encoder(IOStream *stream) : gl2_encoder_context_t(stream)
     m_error = GL_NO_ERROR;
     m_num_compressedTextureFormats = 0;
     m_compressedTextureFormats = NULL;
+
     //overrides
-    m_glFlush_enc = set_glFlush(s_glFlush);
-    m_glPixelStorei_enc = set_glPixelStorei(s_glPixelStorei);
-    m_glGetString_enc = set_glGetString(s_glGetString);
-    m_glBindBuffer_enc = set_glBindBuffer(s_glBindBuffer);
-    m_glBufferData_enc = set_glBufferData(s_glBufferData);
-    m_glBufferSubData_enc = set_glBufferSubData(s_glBufferSubData);
-    m_glDeleteBuffers_enc = set_glDeleteBuffers(s_glDeleteBuffers);
-    m_glDrawArrays_enc = set_glDrawArrays(s_glDrawArrays);
-    m_glDrawElements_enc = set_glDrawElements(s_glDrawElements);
-    m_glGetIntegerv_enc = set_glGetIntegerv(s_glGetIntegerv);
-    m_glGetFloatv_enc = set_glGetFloatv(s_glGetFloatv);
-    m_glGetBooleanv_enc = set_glGetBooleanv(s_glGetBooleanv);
-    m_glVertexAttribPointer_enc = set_glVertexAttribPointer(s_glVertexAtrribPointer);
-    m_glEnableVertexAttribArray_enc = set_glEnableVertexAttribArray(s_glEnableVertexAttribArray);
-    m_glDisableVertexAttribArray_enc = set_glDisableVertexAttribArray(s_glDisableVertexAttribArray);
-    m_glGetVertexAttribiv_enc = set_glGetVertexAttribiv(s_glGetVertexAttribiv);
-    m_glGetVertexAttribfv_enc = set_glGetVertexAttribfv(s_glGetVertexAttribfv);
-    m_glGetVertexAttribPointerv = set_glGetVertexAttribPointerv(s_glGetVertexAttribPointerv);
-    set_glShaderSource(s_glShaderSource);
-    set_glFinish(s_glFinish);
-    m_glGetError_enc = set_glGetError(s_glGetError);
-    m_glLinkProgram_enc = set_glLinkProgram(s_glLinkProgram);
-    m_glDeleteProgram_enc = set_glDeleteProgram(s_glDeleteProgram);
-    m_glGetUniformiv_enc = set_glGetUniformiv(s_glGetUniformiv);
-    m_glGetUniformfv_enc = set_glGetUniformfv(s_glGetUniformfv);
-    m_glCreateProgram_enc = set_glCreateProgram(s_glCreateProgram);
-    m_glCreateShader_enc = set_glCreateShader(s_glCreateShader);
-    m_glDeleteShader_enc = set_glDeleteShader(s_glDeleteShader);
-    m_glAttachShader_enc = set_glAttachShader(s_glAttachShader);
-    m_glDetachShader_enc = set_glDetachShader(s_glDetachShader);
-    m_glGetAttachedShaders_enc = set_glGetAttachedShaders(s_glGetAttachedShaders);
-    m_glGetShaderSource_enc = set_glGetShaderSource(s_glGetShaderSource);
-    m_glGetShaderInfoLog_enc = set_glGetShaderInfoLog(s_glGetShaderInfoLog);
-    m_glGetProgramInfoLog_enc = set_glGetProgramInfoLog(s_glGetProgramInfoLog);
-
-    m_glGetUniformLocation_enc = set_glGetUniformLocation(s_glGetUniformLocation);
-    m_glUseProgram_enc = set_glUseProgram(s_glUseProgram);
-
-    m_glUniform1f_enc = set_glUniform1f(s_glUniform1f);
-    m_glUniform1fv_enc = set_glUniform1fv(s_glUniform1fv);
-    m_glUniform1i_enc = set_glUniform1i(s_glUniform1i);
-    m_glUniform1iv_enc = set_glUniform1iv(s_glUniform1iv);
-    m_glUniform2f_enc = set_glUniform2f(s_glUniform2f);
-    m_glUniform2fv_enc = set_glUniform2fv(s_glUniform2fv);
-    m_glUniform2i_enc = set_glUniform2i(s_glUniform2i);
-    m_glUniform2iv_enc = set_glUniform2iv(s_glUniform2iv);
-    m_glUniform3f_enc = set_glUniform3f(s_glUniform3f);
-    m_glUniform3fv_enc = set_glUniform3fv(s_glUniform3fv);
-    m_glUniform3i_enc = set_glUniform3i(s_glUniform3i);
-    m_glUniform3iv_enc = set_glUniform3iv(s_glUniform3iv);
-    m_glUniform4f_enc = set_glUniform4f(s_glUniform4f);
-    m_glUniform4fv_enc = set_glUniform4fv(s_glUniform4fv);
-    m_glUniform4i_enc = set_glUniform4i(s_glUniform4i);
-    m_glUniform4iv_enc = set_glUniform4iv(s_glUniform4iv);
-    m_glUniformMatrix2fv_enc = set_glUniformMatrix2fv(s_glUniformMatrix2fv);
-    m_glUniformMatrix3fv_enc = set_glUniformMatrix3fv(s_glUniformMatrix3fv);
-    m_glUniformMatrix4fv_enc = set_glUniformMatrix4fv(s_glUniformMatrix4fv);
-
-    m_glActiveTexture_enc = set_glActiveTexture(s_glActiveTexture);
-    m_glBindTexture_enc = set_glBindTexture(s_glBindTexture);
-    m_glDeleteTextures_enc = set_glDeleteTextures(s_glDeleteTextures);
-    m_glGetTexParameterfv_enc = set_glGetTexParameterfv(s_glGetTexParameterfv);
-    m_glGetTexParameteriv_enc = set_glGetTexParameteriv(s_glGetTexParameteriv);
-    m_glTexParameterf_enc = set_glTexParameterf(s_glTexParameterf);
-    m_glTexParameterfv_enc = set_glTexParameterfv(s_glTexParameterfv);
-    m_glTexParameteri_enc = set_glTexParameteri(s_glTexParameteri);
-    m_glTexParameteriv_enc = set_glTexParameteriv(s_glTexParameteriv);
+#define OVERRIDE(name)  m_##name##_enc = this-> name ; this-> name = &s_##name
+
+    OVERRIDE(glFlush);
+    OVERRIDE(glPixelStorei);
+    OVERRIDE(glGetString);
+    OVERRIDE(glBindBuffer);
+    OVERRIDE(glBufferData);
+    OVERRIDE(glBufferSubData);
+    OVERRIDE(glDeleteBuffers);
+    OVERRIDE(glDrawArrays);
+    OVERRIDE(glDrawElements);
+    OVERRIDE(glGetIntegerv);
+    OVERRIDE(glGetFloatv);
+    OVERRIDE(glGetBooleanv);
+    OVERRIDE(glVertexAttribPointer);
+    OVERRIDE(glEnableVertexAttribArray);
+    OVERRIDE(glDisableVertexAttribArray);
+    OVERRIDE(glGetVertexAttribiv);
+    OVERRIDE(glGetVertexAttribfv);
+    OVERRIDE(glGetVertexAttribPointerv);
+
+    this->glShaderSource = &s_glShaderSource;
+    this->glFinish = &s_glFinish;
+
+    OVERRIDE(glGetError);
+    OVERRIDE(glLinkProgram);
+    OVERRIDE(glDeleteProgram);
+    OVERRIDE(glGetUniformiv);
+    OVERRIDE(glGetUniformfv);
+    OVERRIDE(glCreateProgram);
+    OVERRIDE(glCreateShader);
+    OVERRIDE(glDeleteShader);
+    OVERRIDE(glAttachShader);
+    OVERRIDE(glDetachShader);
+    OVERRIDE(glGetAttachedShaders);
+    OVERRIDE(glGetShaderSource);
+    OVERRIDE(glGetShaderInfoLog);
+    OVERRIDE(glGetProgramInfoLog);
+
+    OVERRIDE(glGetUniformLocation);
+    OVERRIDE(glUseProgram);
+
+    OVERRIDE(glUniform1f);
+    OVERRIDE(glUniform1fv);
+    OVERRIDE(glUniform1i);
+    OVERRIDE(glUniform1iv);
+    OVERRIDE(glUniform2f);
+    OVERRIDE(glUniform2fv);
+    OVERRIDE(glUniform2i);
+    OVERRIDE(glUniform2iv);
+    OVERRIDE(glUniform3f);
+    OVERRIDE(glUniform3fv);
+    OVERRIDE(glUniform3i);
+    OVERRIDE(glUniform3iv);
+    OVERRIDE(glUniform4f);
+    OVERRIDE(glUniform4fv);
+    OVERRIDE(glUniform4i);
+    OVERRIDE(glUniform4iv);
+    OVERRIDE(glUniformMatrix2fv);
+    OVERRIDE(glUniformMatrix3fv);
+    OVERRIDE(glUniformMatrix4fv);
+
+    OVERRIDE(glActiveTexture);
+    OVERRIDE(glBindTexture);
+    OVERRIDE(glDeleteTextures);
+    OVERRIDE(glGetTexParameterfv);
+    OVERRIDE(glGetTexParameteriv);
+    OVERRIDE(glTexParameterf);
+    OVERRIDE(glTexParameterfv);
+    OVERRIDE(glTexParameteri);
+    OVERRIDE(glTexParameteriv);
+    OVERRIDE(glTexImage2D);
 }
 
 GL2Encoder::~GL2Encoder()
@@ -145,6 +151,8 @@ void GL2Encoder::s_glFlush(void *self)
 
 const GLubyte *GL2Encoder::s_glGetString(void *self, GLenum name)
 {
+    (void)self;
+
     GLubyte *retval =  (GLubyte *) "";
     switch(name) {
     case GL_VENDOR:
@@ -184,6 +192,7 @@ void GL2Encoder::s_glBindBuffer(void *self, GLenum target, GLuint id)
 void GL2Encoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)
 {
     GL2Encoder *ctx = (GL2Encoder *) self;
+    SET_ERROR_IF(!(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM);
     GLuint bufferId = ctx->m_state->getBuffer(target);
     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
     SET_ERROR_IF(size<0, GL_INVALID_VALUE);
@@ -195,6 +204,7 @@ void GL2Encoder::s_glBufferData(void * self, GLenum target, GLsizeiptr size, con
 void GL2Encoder::s_glBufferSubData(void * self, GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)
 {
     GL2Encoder *ctx = (GL2Encoder *) self;
+    SET_ERROR_IF(!(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM);
     GLuint bufferId = ctx->m_state->getBuffer(target);
     SET_ERROR_IF(bufferId==0, GL_INVALID_OPERATION);
 
@@ -210,11 +220,12 @@ void GL2Encoder::s_glDeleteBuffers(void * self, GLsizei n, const GLuint * buffer
     SET_ERROR_IF(n<0, GL_INVALID_VALUE);
     for (int i=0; i<n; i++) {
         ctx->m_shared->deleteBufferData(buffers[i]);
+        ctx->m_state->unBindBuffer(buffers[i]);
         ctx->m_glDeleteBuffers_enc(self,1,&buffers[i]);
     }
 }
 
-void GL2Encoder::s_glVertexAtrribPointer(void *self, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * ptr)
+void GL2Encoder::s_glVertexAttribPointer(void *self, GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * ptr)
 {
     GL2Encoder *ctx = (GL2Encoder *)self;
     assert(ctx->m_state != NULL);
@@ -353,6 +364,7 @@ void GL2Encoder::s_glGetBooleanv(void *self, GLenum param, GLboolean *ptr)
         if (!ctx->m_state->getClientStateParameter<GLboolean>(param, ptr)) {
             ctx->m_glGetBooleanv_enc(self, param, ptr);
         }
+        *ptr = (*ptr != 0) ? GL_TRUE : GL_FALSE;
         break;
     }
 }
@@ -398,6 +410,8 @@ void GL2Encoder::s_glGetVertexAttribPointerv(void *self, GLuint index, GLenum pn
     GL2Encoder *ctx = (GL2Encoder *)self;
     if (ctx->m_state == NULL) return;
 
+    (void)pname;
+
     const GLClientState::VertexAttribState *va_state = ctx->m_state->getState(index);
     if (va_state != NULL) {
         *pointer = va_state->data;
@@ -638,7 +652,7 @@ static bool replaceSamplerExternalWith2D(char* const str, ShaderData* const data
     return true;
 }
 
-void GL2Encoder::s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
+void GL2Encoder::s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar * const *string, const GLint *length)
 {
     GL2Encoder* ctx = (GL2Encoder*)self;
     ShaderData* shaderData = ctx->m_shared->getShaderData(shader);
@@ -1198,6 +1212,23 @@ void GL2Encoder::s_glTexParameteri(void* self,
     }
 }
 
+void GL2Encoder::s_glTexImage2D(void* self, GLenum target, GLint level,
+        GLint internalformat, GLsizei width, GLsizei height, GLint border,
+        GLenum format, GLenum type, const GLvoid* pixels)
+{
+    GL2Encoder* ctx = (GL2Encoder*)self;
+    if (target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES) {
+        ctx->override2DTextureTarget(target);
+        ctx->m_glTexImage2D_enc(ctx, target, level, internalformat, width,
+                height, border, format, type, pixels);
+        ctx->restore2DTextureTarget();
+    } else {
+        ctx->m_glTexImage2D_enc(ctx, target, level, internalformat, width,
+                height, border, format, type, pixels);
+    }
+}
+
+
 void GL2Encoder::s_glTexParameteriv(void* self,
         GLenum target, GLenum pname, const GLint* params)
 {
diff --git a/opengl/system/GLESv2_enc/GL2Encoder.h b/opengl/system/GLESv2_enc/GL2Encoder.h
index 8f6204c..5f255d1 100644
--- a/opengl/system/GLESv2_enc/GL2Encoder.h
+++ b/opengl/system/GLESv2_enc/GL2Encoder.h
@@ -99,7 +99,7 @@ private:
     static void s_glGetBooleanv(void *self, GLenum pname, GLboolean *ptr);
 
     glVertexAttribPointer_client_proc_t m_glVertexAttribPointer_enc;
-    static void s_glVertexAtrribPointer(void *self, GLuint indx, GLint size, GLenum type,
+    static void s_glVertexAttribPointer(void *self, GLuint indx, GLint size, GLenum type,
                                         GLboolean normalized, GLsizei stride, const GLvoid * ptr);
 
     glEnableVertexAttribArray_client_proc_t m_glEnableVertexAttribArray_enc;
@@ -114,10 +114,10 @@ private:
     glGetVertexAttribfv_client_proc_t m_glGetVertexAttribfv_enc;
     static void s_glGetVertexAttribfv(void *self, GLuint index, GLenum pname, GLfloat *params);
 
-    glGetVertexAttribPointerv_client_proc_t m_glGetVertexAttribPointerv;
+    glGetVertexAttribPointerv_client_proc_t m_glGetVertexAttribPointerv_enc;
     static void s_glGetVertexAttribPointerv(void *self, GLuint index, GLenum pname, GLvoid **pointer);
 
-    static void s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length);
+    static void s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar * const *string, const GLint *length);
 
     static void s_glFinish(void *self);
 
@@ -218,6 +218,7 @@ private:
     glTexParameterfv_client_proc_t m_glTexParameterfv_enc;
     glTexParameteri_client_proc_t m_glTexParameteri_enc;
     glTexParameteriv_client_proc_t m_glTexParameteriv_enc;
+    glTexImage2D_client_proc_t m_glTexImage2D_enc;
 
     static void s_glActiveTexture(void* self, GLenum texture);
     static void s_glBindTexture(void* self, GLenum target, GLuint texture);
@@ -228,5 +229,9 @@ private:
     static void s_glTexParameterfv(void* self, GLenum target, GLenum pname, const GLfloat* params);
     static void s_glTexParameteri(void* self, GLenum target, GLenum pname, GLint param);
     static void s_glTexParameteriv(void* self, GLenum target, GLenum pname, const GLint* params);
+    static void s_glTexImage2D(void* self, GLenum target, GLint level, GLint internalformat,
+            GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
+            const GLvoid* pixels);
+
 };
 #endif
diff --git a/opengl/system/GLESv2_enc/GL2EncoderUtils.cpp b/opengl/system/GLESv2_enc/GL2EncoderUtils.cpp
index 57d65c0..fc2a723 100644
--- a/opengl/system/GLESv2_enc/GL2EncoderUtils.cpp
+++ b/opengl/system/GLESv2_enc/GL2EncoderUtils.cpp
@@ -18,6 +18,8 @@
 #include "GL2Encoder.h"
 #include <assert.h>
 
+namespace glesv2_enc {
+
 size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack)
 {
     GL2Encoder *ctx = (GL2Encoder *)self;
@@ -37,3 +39,5 @@ GLenum uniformType(void * self, GLuint program, GLint location)
     assert (ctx->shared() != NULL);
     return ctx->shared()->getProgramUniformType(program, location);
 }
+
+}  // namespace glesv2_enc
diff --git a/opengl/system/GLESv2_enc/GL2EncoderUtils.h b/opengl/system/GLESv2_enc/GL2EncoderUtils.h
index 8e91aeb..4afec10 100644
--- a/opengl/system/GLESv2_enc/GL2EncoderUtils.h
+++ b/opengl/system/GLESv2_enc/GL2EncoderUtils.h
@@ -16,9 +16,12 @@
 #ifndef GL2_ENCODER_UTILS_H
 #define GL2_ENCLODER_UTILS_H
 
-extern "C" {
-    size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack);
-    size_t pixelDataSize3D(void *self, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack);
-    GLenum uniformType(void * self, GLuint program, GLint location);
-};
+namespace glesv2_enc {
+
+size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack);
+size_t pixelDataSize3D(void *self, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack);
+GLenum uniformType(void * self, GLuint program, GLint location);
+
+}  // namespace glesv2_enc
+
 #endif
diff --git a/opengl/system/GLESv2_enc/gl2_client_context.cpp b/opengl/system/GLESv2_enc/gl2_client_context.cpp
index e4e08b2..f903542 100644
--- a/opengl/system/GLESv2_enc/gl2_client_context.cpp
+++ b/opengl/system/GLESv2_enc/gl2_client_context.cpp
@@ -10,216 +10,214 @@
 
 int gl2_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData)
 {
-	void *ptr;
-
-	ptr = getProc("glActiveTexture", userData); set_glActiveTexture((glActiveTexture_client_proc_t)ptr);
-	ptr = getProc("glAttachShader", userData); set_glAttachShader((glAttachShader_client_proc_t)ptr);
-	ptr = getProc("glBindAttribLocation", userData); set_glBindAttribLocation((glBindAttribLocation_client_proc_t)ptr);
-	ptr = getProc("glBindBuffer", userData); set_glBindBuffer((glBindBuffer_client_proc_t)ptr);
-	ptr = getProc("glBindFramebuffer", userData); set_glBindFramebuffer((glBindFramebuffer_client_proc_t)ptr);
-	ptr = getProc("glBindRenderbuffer", userData); set_glBindRenderbuffer((glBindRenderbuffer_client_proc_t)ptr);
-	ptr = getProc("glBindTexture", userData); set_glBindTexture((glBindTexture_client_proc_t)ptr);
-	ptr = getProc("glBlendColor", userData); set_glBlendColor((glBlendColor_client_proc_t)ptr);
-	ptr = getProc("glBlendEquation", userData); set_glBlendEquation((glBlendEquation_client_proc_t)ptr);
-	ptr = getProc("glBlendEquationSeparate", userData); set_glBlendEquationSeparate((glBlendEquationSeparate_client_proc_t)ptr);
-	ptr = getProc("glBlendFunc", userData); set_glBlendFunc((glBlendFunc_client_proc_t)ptr);
-	ptr = getProc("glBlendFuncSeparate", userData); set_glBlendFuncSeparate((glBlendFuncSeparate_client_proc_t)ptr);
-	ptr = getProc("glBufferData", userData); set_glBufferData((glBufferData_client_proc_t)ptr);
-	ptr = getProc("glBufferSubData", userData); set_glBufferSubData((glBufferSubData_client_proc_t)ptr);
-	ptr = getProc("glCheckFramebufferStatus", userData); set_glCheckFramebufferStatus((glCheckFramebufferStatus_client_proc_t)ptr);
-	ptr = getProc("glClear", userData); set_glClear((glClear_client_proc_t)ptr);
-	ptr = getProc("glClearColor", userData); set_glClearColor((glClearColor_client_proc_t)ptr);
-	ptr = getProc("glClearDepthf", userData); set_glClearDepthf((glClearDepthf_client_proc_t)ptr);
-	ptr = getProc("glClearStencil", userData); set_glClearStencil((glClearStencil_client_proc_t)ptr);
-	ptr = getProc("glColorMask", userData); set_glColorMask((glColorMask_client_proc_t)ptr);
-	ptr = getProc("glCompileShader", userData); set_glCompileShader((glCompileShader_client_proc_t)ptr);
-	ptr = getProc("glCompressedTexImage2D", userData); set_glCompressedTexImage2D((glCompressedTexImage2D_client_proc_t)ptr);
-	ptr = getProc("glCompressedTexSubImage2D", userData); set_glCompressedTexSubImage2D((glCompressedTexSubImage2D_client_proc_t)ptr);
-	ptr = getProc("glCopyTexImage2D", userData); set_glCopyTexImage2D((glCopyTexImage2D_client_proc_t)ptr);
-	ptr = getProc("glCopyTexSubImage2D", userData); set_glCopyTexSubImage2D((glCopyTexSubImage2D_client_proc_t)ptr);
-	ptr = getProc("glCreateProgram", userData); set_glCreateProgram((glCreateProgram_client_proc_t)ptr);
-	ptr = getProc("glCreateShader", userData); set_glCreateShader((glCreateShader_client_proc_t)ptr);
-	ptr = getProc("glCullFace", userData); set_glCullFace((glCullFace_client_proc_t)ptr);
-	ptr = getProc("glDeleteBuffers", userData); set_glDeleteBuffers((glDeleteBuffers_client_proc_t)ptr);
-	ptr = getProc("glDeleteFramebuffers", userData); set_glDeleteFramebuffers((glDeleteFramebuffers_client_proc_t)ptr);
-	ptr = getProc("glDeleteProgram", userData); set_glDeleteProgram((glDeleteProgram_client_proc_t)ptr);
-	ptr = getProc("glDeleteRenderbuffers", userData); set_glDeleteRenderbuffers((glDeleteRenderbuffers_client_proc_t)ptr);
-	ptr = getProc("glDeleteShader", userData); set_glDeleteShader((glDeleteShader_client_proc_t)ptr);
-	ptr = getProc("glDeleteTextures", userData); set_glDeleteTextures((glDeleteTextures_client_proc_t)ptr);
-	ptr = getProc("glDepthFunc", userData); set_glDepthFunc((glDepthFunc_client_proc_t)ptr);
-	ptr = getProc("glDepthMask", userData); set_glDepthMask((glDepthMask_client_proc_t)ptr);
-	ptr = getProc("glDepthRangef", userData); set_glDepthRangef((glDepthRangef_client_proc_t)ptr);
-	ptr = getProc("glDetachShader", userData); set_glDetachShader((glDetachShader_client_proc_t)ptr);
-	ptr = getProc("glDisable", userData); set_glDisable((glDisable_client_proc_t)ptr);
-	ptr = getProc("glDisableVertexAttribArray", userData); set_glDisableVertexAttribArray((glDisableVertexAttribArray_client_proc_t)ptr);
-	ptr = getProc("glDrawArrays", userData); set_glDrawArrays((glDrawArrays_client_proc_t)ptr);
-	ptr = getProc("glDrawElements", userData); set_glDrawElements((glDrawElements_client_proc_t)ptr);
-	ptr = getProc("glEnable", userData); set_glEnable((glEnable_client_proc_t)ptr);
-	ptr = getProc("glEnableVertexAttribArray", userData); set_glEnableVertexAttribArray((glEnableVertexAttribArray_client_proc_t)ptr);
-	ptr = getProc("glFinish", userData); set_glFinish((glFinish_client_proc_t)ptr);
-	ptr = getProc("glFlush", userData); set_glFlush((glFlush_client_proc_t)ptr);
-	ptr = getProc("glFramebufferRenderbuffer", userData); set_glFramebufferRenderbuffer((glFramebufferRenderbuffer_client_proc_t)ptr);
-	ptr = getProc("glFramebufferTexture2D", userData); set_glFramebufferTexture2D((glFramebufferTexture2D_client_proc_t)ptr);
-	ptr = getProc("glFrontFace", userData); set_glFrontFace((glFrontFace_client_proc_t)ptr);
-	ptr = getProc("glGenBuffers", userData); set_glGenBuffers((glGenBuffers_client_proc_t)ptr);
-	ptr = getProc("glGenerateMipmap", userData); set_glGenerateMipmap((glGenerateMipmap_client_proc_t)ptr);
-	ptr = getProc("glGenFramebuffers", userData); set_glGenFramebuffers((glGenFramebuffers_client_proc_t)ptr);
-	ptr = getProc("glGenRenderbuffers", userData); set_glGenRenderbuffers((glGenRenderbuffers_client_proc_t)ptr);
-	ptr = getProc("glGenTextures", userData); set_glGenTextures((glGenTextures_client_proc_t)ptr);
-	ptr = getProc("glGetActiveAttrib", userData); set_glGetActiveAttrib((glGetActiveAttrib_client_proc_t)ptr);
-	ptr = getProc("glGetActiveUniform", userData); set_glGetActiveUniform((glGetActiveUniform_client_proc_t)ptr);
-	ptr = getProc("glGetAttachedShaders", userData); set_glGetAttachedShaders((glGetAttachedShaders_client_proc_t)ptr);
-	ptr = getProc("glGetAttribLocation", userData); set_glGetAttribLocation((glGetAttribLocation_client_proc_t)ptr);
-	ptr = getProc("glGetBooleanv", userData); set_glGetBooleanv((glGetBooleanv_client_proc_t)ptr);
-	ptr = getProc("glGetBufferParameteriv", userData); set_glGetBufferParameteriv((glGetBufferParameteriv_client_proc_t)ptr);
-	ptr = getProc("glGetError", userData); set_glGetError((glGetError_client_proc_t)ptr);
-	ptr = getProc("glGetFloatv", userData); set_glGetFloatv((glGetFloatv_client_proc_t)ptr);
-	ptr = getProc("glGetFramebufferAttachmentParameteriv", userData); set_glGetFramebufferAttachmentParameteriv((glGetFramebufferAttachmentParameteriv_client_proc_t)ptr);
-	ptr = getProc("glGetIntegerv", userData); set_glGetIntegerv((glGetIntegerv_client_proc_t)ptr);
-	ptr = getProc("glGetProgramiv", userData); set_glGetProgramiv((glGetProgramiv_client_proc_t)ptr);
-	ptr = getProc("glGetProgramInfoLog", userData); set_glGetProgramInfoLog((glGetProgramInfoLog_client_proc_t)ptr);
-	ptr = getProc("glGetRenderbufferParameteriv", userData); set_glGetRenderbufferParameteriv((glGetRenderbufferParameteriv_client_proc_t)ptr);
-	ptr = getProc("glGetShaderiv", userData); set_glGetShaderiv((glGetShaderiv_client_proc_t)ptr);
-	ptr = getProc("glGetShaderInfoLog", userData); set_glGetShaderInfoLog((glGetShaderInfoLog_client_proc_t)ptr);
-	ptr = getProc("glGetShaderPrecisionFormat", userData); set_glGetShaderPrecisionFormat((glGetShaderPrecisionFormat_client_proc_t)ptr);
-	ptr = getProc("glGetShaderSource", userData); set_glGetShaderSource((glGetShaderSource_client_proc_t)ptr);
-	ptr = getProc("glGetString", userData); set_glGetString((glGetString_client_proc_t)ptr);
-	ptr = getProc("glGetTexParameterfv", userData); set_glGetTexParameterfv((glGetTexParameterfv_client_proc_t)ptr);
-	ptr = getProc("glGetTexParameteriv", userData); set_glGetTexParameteriv((glGetTexParameteriv_client_proc_t)ptr);
-	ptr = getProc("glGetUniformfv", userData); set_glGetUniformfv((glGetUniformfv_client_proc_t)ptr);
-	ptr = getProc("glGetUniformiv", userData); set_glGetUniformiv((glGetUniformiv_client_proc_t)ptr);
-	ptr = getProc("glGetUniformLocation", userData); set_glGetUniformLocation((glGetUniformLocation_client_proc_t)ptr);
-	ptr = getProc("glGetVertexAttribfv", userData); set_glGetVertexAttribfv((glGetVertexAttribfv_client_proc_t)ptr);
-	ptr = getProc("glGetVertexAttribiv", userData); set_glGetVertexAttribiv((glGetVertexAttribiv_client_proc_t)ptr);
-	ptr = getProc("glGetVertexAttribPointerv", userData); set_glGetVertexAttribPointerv((glGetVertexAttribPointerv_client_proc_t)ptr);
-	ptr = getProc("glHint", userData); set_glHint((glHint_client_proc_t)ptr);
-	ptr = getProc("glIsBuffer", userData); set_glIsBuffer((glIsBuffer_client_proc_t)ptr);
-	ptr = getProc("glIsEnabled", userData); set_glIsEnabled((glIsEnabled_client_proc_t)ptr);
-	ptr = getProc("glIsFramebuffer", userData); set_glIsFramebuffer((glIsFramebuffer_client_proc_t)ptr);
-	ptr = getProc("glIsProgram", userData); set_glIsProgram((glIsProgram_client_proc_t)ptr);
-	ptr = getProc("glIsRenderbuffer", userData); set_glIsRenderbuffer((glIsRenderbuffer_client_proc_t)ptr);
-	ptr = getProc("glIsShader", userData); set_glIsShader((glIsShader_client_proc_t)ptr);
-	ptr = getProc("glIsTexture", userData); set_glIsTexture((glIsTexture_client_proc_t)ptr);
-	ptr = getProc("glLineWidth", userData); set_glLineWidth((glLineWidth_client_proc_t)ptr);
-	ptr = getProc("glLinkProgram", userData); set_glLinkProgram((glLinkProgram_client_proc_t)ptr);
-	ptr = getProc("glPixelStorei", userData); set_glPixelStorei((glPixelStorei_client_proc_t)ptr);
-	ptr = getProc("glPolygonOffset", userData); set_glPolygonOffset((glPolygonOffset_client_proc_t)ptr);
-	ptr = getProc("glReadPixels", userData); set_glReadPixels((glReadPixels_client_proc_t)ptr);
-	ptr = getProc("glReleaseShaderCompiler", userData); set_glReleaseShaderCompiler((glReleaseShaderCompiler_client_proc_t)ptr);
-	ptr = getProc("glRenderbufferStorage", userData); set_glRenderbufferStorage((glRenderbufferStorage_client_proc_t)ptr);
-	ptr = getProc("glSampleCoverage", userData); set_glSampleCoverage((glSampleCoverage_client_proc_t)ptr);
-	ptr = getProc("glScissor", userData); set_glScissor((glScissor_client_proc_t)ptr);
-	ptr = getProc("glShaderBinary", userData); set_glShaderBinary((glShaderBinary_client_proc_t)ptr);
-	ptr = getProc("glShaderSource", userData); set_glShaderSource((glShaderSource_client_proc_t)ptr);
-	ptr = getProc("glStencilFunc", userData); set_glStencilFunc((glStencilFunc_client_proc_t)ptr);
-	ptr = getProc("glStencilFuncSeparate", userData); set_glStencilFuncSeparate((glStencilFuncSeparate_client_proc_t)ptr);
-	ptr = getProc("glStencilMask", userData); set_glStencilMask((glStencilMask_client_proc_t)ptr);
-	ptr = getProc("glStencilMaskSeparate", userData); set_glStencilMaskSeparate((glStencilMaskSeparate_client_proc_t)ptr);
-	ptr = getProc("glStencilOp", userData); set_glStencilOp((glStencilOp_client_proc_t)ptr);
-	ptr = getProc("glStencilOpSeparate", userData); set_glStencilOpSeparate((glStencilOpSeparate_client_proc_t)ptr);
-	ptr = getProc("glTexImage2D", userData); set_glTexImage2D((glTexImage2D_client_proc_t)ptr);
-	ptr = getProc("glTexParameterf", userData); set_glTexParameterf((glTexParameterf_client_proc_t)ptr);
-	ptr = getProc("glTexParameterfv", userData); set_glTexParameterfv((glTexParameterfv_client_proc_t)ptr);
-	ptr = getProc("glTexParameteri", userData); set_glTexParameteri((glTexParameteri_client_proc_t)ptr);
-	ptr = getProc("glTexParameteriv", userData); set_glTexParameteriv((glTexParameteriv_client_proc_t)ptr);
-	ptr = getProc("glTexSubImage2D", userData); set_glTexSubImage2D((glTexSubImage2D_client_proc_t)ptr);
-	ptr = getProc("glUniform1f", userData); set_glUniform1f((glUniform1f_client_proc_t)ptr);
-	ptr = getProc("glUniform1fv", userData); set_glUniform1fv((glUniform1fv_client_proc_t)ptr);
-	ptr = getProc("glUniform1i", userData); set_glUniform1i((glUniform1i_client_proc_t)ptr);
-	ptr = getProc("glUniform1iv", userData); set_glUniform1iv((glUniform1iv_client_proc_t)ptr);
-	ptr = getProc("glUniform2f", userData); set_glUniform2f((glUniform2f_client_proc_t)ptr);
-	ptr = getProc("glUniform2fv", userData); set_glUniform2fv((glUniform2fv_client_proc_t)ptr);
-	ptr = getProc("glUniform2i", userData); set_glUniform2i((glUniform2i_client_proc_t)ptr);
-	ptr = getProc("glUniform2iv", userData); set_glUniform2iv((glUniform2iv_client_proc_t)ptr);
-	ptr = getProc("glUniform3f", userData); set_glUniform3f((glUniform3f_client_proc_t)ptr);
-	ptr = getProc("glUniform3fv", userData); set_glUniform3fv((glUniform3fv_client_proc_t)ptr);
-	ptr = getProc("glUniform3i", userData); set_glUniform3i((glUniform3i_client_proc_t)ptr);
-	ptr = getProc("glUniform3iv", userData); set_glUniform3iv((glUniform3iv_client_proc_t)ptr);
-	ptr = getProc("glUniform4f", userData); set_glUniform4f((glUniform4f_client_proc_t)ptr);
-	ptr = getProc("glUniform4fv", userData); set_glUniform4fv((glUniform4fv_client_proc_t)ptr);
-	ptr = getProc("glUniform4i", userData); set_glUniform4i((glUniform4i_client_proc_t)ptr);
-	ptr = getProc("glUniform4iv", userData); set_glUniform4iv((glUniform4iv_client_proc_t)ptr);
-	ptr = getProc("glUniformMatrix2fv", userData); set_glUniformMatrix2fv((glUniformMatrix2fv_client_proc_t)ptr);
-	ptr = getProc("glUniformMatrix3fv", userData); set_glUniformMatrix3fv((glUniformMatrix3fv_client_proc_t)ptr);
-	ptr = getProc("glUniformMatrix4fv", userData); set_glUniformMatrix4fv((glUniformMatrix4fv_client_proc_t)ptr);
-	ptr = getProc("glUseProgram", userData); set_glUseProgram((glUseProgram_client_proc_t)ptr);
-	ptr = getProc("glValidateProgram", userData); set_glValidateProgram((glValidateProgram_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib1f", userData); set_glVertexAttrib1f((glVertexAttrib1f_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib1fv", userData); set_glVertexAttrib1fv((glVertexAttrib1fv_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib2f", userData); set_glVertexAttrib2f((glVertexAttrib2f_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib2fv", userData); set_glVertexAttrib2fv((glVertexAttrib2fv_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib3f", userData); set_glVertexAttrib3f((glVertexAttrib3f_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib3fv", userData); set_glVertexAttrib3fv((glVertexAttrib3fv_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib4f", userData); set_glVertexAttrib4f((glVertexAttrib4f_client_proc_t)ptr);
-	ptr = getProc("glVertexAttrib4fv", userData); set_glVertexAttrib4fv((glVertexAttrib4fv_client_proc_t)ptr);
-	ptr = getProc("glVertexAttribPointer", userData); set_glVertexAttribPointer((glVertexAttribPointer_client_proc_t)ptr);
-	ptr = getProc("glViewport", userData); set_glViewport((glViewport_client_proc_t)ptr);
-	ptr = getProc("glEGLImageTargetTexture2DOES", userData); set_glEGLImageTargetTexture2DOES((glEGLImageTargetTexture2DOES_client_proc_t)ptr);
-	ptr = getProc("glEGLImageTargetRenderbufferStorageOES", userData); set_glEGLImageTargetRenderbufferStorageOES((glEGLImageTargetRenderbufferStorageOES_client_proc_t)ptr);
-	ptr = getProc("glGetProgramBinaryOES", userData); set_glGetProgramBinaryOES((glGetProgramBinaryOES_client_proc_t)ptr);
-	ptr = getProc("glProgramBinaryOES", userData); set_glProgramBinaryOES((glProgramBinaryOES_client_proc_t)ptr);
-	ptr = getProc("glMapBufferOES", userData); set_glMapBufferOES((glMapBufferOES_client_proc_t)ptr);
-	ptr = getProc("glUnmapBufferOES", userData); set_glUnmapBufferOES((glUnmapBufferOES_client_proc_t)ptr);
-	ptr = getProc("glTexImage3DOES", userData); set_glTexImage3DOES((glTexImage3DOES_client_proc_t)ptr);
-	ptr = getProc("glTexSubImage3DOES", userData); set_glTexSubImage3DOES((glTexSubImage3DOES_client_proc_t)ptr);
-	ptr = getProc("glCopyTexSubImage3DOES", userData); set_glCopyTexSubImage3DOES((glCopyTexSubImage3DOES_client_proc_t)ptr);
-	ptr = getProc("glCompressedTexImage3DOES", userData); set_glCompressedTexImage3DOES((glCompressedTexImage3DOES_client_proc_t)ptr);
-	ptr = getProc("glCompressedTexSubImage3DOES", userData); set_glCompressedTexSubImage3DOES((glCompressedTexSubImage3DOES_client_proc_t)ptr);
-	ptr = getProc("glFramebufferTexture3DOES", userData); set_glFramebufferTexture3DOES((glFramebufferTexture3DOES_client_proc_t)ptr);
-	ptr = getProc("glBindVertexArrayOES", userData); set_glBindVertexArrayOES((glBindVertexArrayOES_client_proc_t)ptr);
-	ptr = getProc("glDeleteVertexArraysOES", userData); set_glDeleteVertexArraysOES((glDeleteVertexArraysOES_client_proc_t)ptr);
-	ptr = getProc("glGenVertexArraysOES", userData); set_glGenVertexArraysOES((glGenVertexArraysOES_client_proc_t)ptr);
-	ptr = getProc("glIsVertexArrayOES", userData); set_glIsVertexArrayOES((glIsVertexArrayOES_client_proc_t)ptr);
-	ptr = getProc("glDiscardFramebufferEXT", userData); set_glDiscardFramebufferEXT((glDiscardFramebufferEXT_client_proc_t)ptr);
-	ptr = getProc("glMultiDrawArraysEXT", userData); set_glMultiDrawArraysEXT((glMultiDrawArraysEXT_client_proc_t)ptr);
-	ptr = getProc("glMultiDrawElementsEXT", userData); set_glMultiDrawElementsEXT((glMultiDrawElementsEXT_client_proc_t)ptr);
-	ptr = getProc("glGetPerfMonitorGroupsAMD", userData); set_glGetPerfMonitorGroupsAMD((glGetPerfMonitorGroupsAMD_client_proc_t)ptr);
-	ptr = getProc("glGetPerfMonitorCountersAMD", userData); set_glGetPerfMonitorCountersAMD((glGetPerfMonitorCountersAMD_client_proc_t)ptr);
-	ptr = getProc("glGetPerfMonitorGroupStringAMD", userData); set_glGetPerfMonitorGroupStringAMD((glGetPerfMonitorGroupStringAMD_client_proc_t)ptr);
-	ptr = getProc("glGetPerfMonitorCounterStringAMD", userData); set_glGetPerfMonitorCounterStringAMD((glGetPerfMonitorCounterStringAMD_client_proc_t)ptr);
-	ptr = getProc("glGetPerfMonitorCounterInfoAMD", userData); set_glGetPerfMonitorCounterInfoAMD((glGetPerfMonitorCounterInfoAMD_client_proc_t)ptr);
-	ptr = getProc("glGenPerfMonitorsAMD", userData); set_glGenPerfMonitorsAMD((glGenPerfMonitorsAMD_client_proc_t)ptr);
-	ptr = getProc("glDeletePerfMonitorsAMD", userData); set_glDeletePerfMonitorsAMD((glDeletePerfMonitorsAMD_client_proc_t)ptr);
-	ptr = getProc("glSelectPerfMonitorCountersAMD", userData); set_glSelectPerfMonitorCountersAMD((glSelectPerfMonitorCountersAMD_client_proc_t)ptr);
-	ptr = getProc("glBeginPerfMonitorAMD", userData); set_glBeginPerfMonitorAMD((glBeginPerfMonitorAMD_client_proc_t)ptr);
-	ptr = getProc("glEndPerfMonitorAMD", userData); set_glEndPerfMonitorAMD((glEndPerfMonitorAMD_client_proc_t)ptr);
-	ptr = getProc("glGetPerfMonitorCounterDataAMD", userData); set_glGetPerfMonitorCounterDataAMD((glGetPerfMonitorCounterDataAMD_client_proc_t)ptr);
-	ptr = getProc("glRenderbufferStorageMultisampleIMG", userData); set_glRenderbufferStorageMultisampleIMG((glRenderbufferStorageMultisampleIMG_client_proc_t)ptr);
-	ptr = getProc("glFramebufferTexture2DMultisampleIMG", userData); set_glFramebufferTexture2DMultisampleIMG((glFramebufferTexture2DMultisampleIMG_client_proc_t)ptr);
-	ptr = getProc("glDeleteFencesNV", userData); set_glDeleteFencesNV((glDeleteFencesNV_client_proc_t)ptr);
-	ptr = getProc("glGenFencesNV", userData); set_glGenFencesNV((glGenFencesNV_client_proc_t)ptr);
-	ptr = getProc("glIsFenceNV", userData); set_glIsFenceNV((glIsFenceNV_client_proc_t)ptr);
-	ptr = getProc("glTestFenceNV", userData); set_glTestFenceNV((glTestFenceNV_client_proc_t)ptr);
-	ptr = getProc("glGetFenceivNV", userData); set_glGetFenceivNV((glGetFenceivNV_client_proc_t)ptr);
-	ptr = getProc("glFinishFenceNV", userData); set_glFinishFenceNV((glFinishFenceNV_client_proc_t)ptr);
-	ptr = getProc("glSetFenceNV", userData); set_glSetFenceNV((glSetFenceNV_client_proc_t)ptr);
-	ptr = getProc("glCoverageMaskNV", userData); set_glCoverageMaskNV((glCoverageMaskNV_client_proc_t)ptr);
-	ptr = getProc("glCoverageOperationNV", userData); set_glCoverageOperationNV((glCoverageOperationNV_client_proc_t)ptr);
-	ptr = getProc("glGetDriverControlsQCOM", userData); set_glGetDriverControlsQCOM((glGetDriverControlsQCOM_client_proc_t)ptr);
-	ptr = getProc("glGetDriverControlStringQCOM", userData); set_glGetDriverControlStringQCOM((glGetDriverControlStringQCOM_client_proc_t)ptr);
-	ptr = getProc("glEnableDriverControlQCOM", userData); set_glEnableDriverControlQCOM((glEnableDriverControlQCOM_client_proc_t)ptr);
-	ptr = getProc("glDisableDriverControlQCOM", userData); set_glDisableDriverControlQCOM((glDisableDriverControlQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetTexturesQCOM", userData); set_glExtGetTexturesQCOM((glExtGetTexturesQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetBuffersQCOM", userData); set_glExtGetBuffersQCOM((glExtGetBuffersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetRenderbuffersQCOM", userData); set_glExtGetRenderbuffersQCOM((glExtGetRenderbuffersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetFramebuffersQCOM", userData); set_glExtGetFramebuffersQCOM((glExtGetFramebuffersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetTexLevelParameterivQCOM", userData); set_glExtGetTexLevelParameterivQCOM((glExtGetTexLevelParameterivQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtTexObjectStateOverrideiQCOM", userData); set_glExtTexObjectStateOverrideiQCOM((glExtTexObjectStateOverrideiQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetTexSubImageQCOM", userData); set_glExtGetTexSubImageQCOM((glExtGetTexSubImageQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetBufferPointervQCOM", userData); set_glExtGetBufferPointervQCOM((glExtGetBufferPointervQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetShadersQCOM", userData); set_glExtGetShadersQCOM((glExtGetShadersQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetProgramsQCOM", userData); set_glExtGetProgramsQCOM((glExtGetProgramsQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtIsProgramBinaryQCOM", userData); set_glExtIsProgramBinaryQCOM((glExtIsProgramBinaryQCOM_client_proc_t)ptr);
-	ptr = getProc("glExtGetProgramBinarySourceQCOM", userData); set_glExtGetProgramBinarySourceQCOM((glExtGetProgramBinarySourceQCOM_client_proc_t)ptr);
-	ptr = getProc("glStartTilingQCOM", userData); set_glStartTilingQCOM((glStartTilingQCOM_client_proc_t)ptr);
-	ptr = getProc("glEndTilingQCOM", userData); set_glEndTilingQCOM((glEndTilingQCOM_client_proc_t)ptr);
-	ptr = getProc("glVertexAttribPointerData", userData); set_glVertexAttribPointerData((glVertexAttribPointerData_client_proc_t)ptr);
-	ptr = getProc("glVertexAttribPointerOffset", userData); set_glVertexAttribPointerOffset((glVertexAttribPointerOffset_client_proc_t)ptr);
-	ptr = getProc("glDrawElementsOffset", userData); set_glDrawElementsOffset((glDrawElementsOffset_client_proc_t)ptr);
-	ptr = getProc("glDrawElementsData", userData); set_glDrawElementsData((glDrawElementsData_client_proc_t)ptr);
-	ptr = getProc("glGetCompressedTextureFormats", userData); set_glGetCompressedTextureFormats((glGetCompressedTextureFormats_client_proc_t)ptr);
-	ptr = getProc("glShaderString", userData); set_glShaderString((glShaderString_client_proc_t)ptr);
-	ptr = getProc("glFinishRoundTrip", userData); set_glFinishRoundTrip((glFinishRoundTrip_client_proc_t)ptr);
+	glActiveTexture = (glActiveTexture_client_proc_t) getProc("glActiveTexture", userData);
+	glAttachShader = (glAttachShader_client_proc_t) getProc("glAttachShader", userData);
+	glBindAttribLocation = (glBindAttribLocation_client_proc_t) getProc("glBindAttribLocation", userData);
+	glBindBuffer = (glBindBuffer_client_proc_t) getProc("glBindBuffer", userData);
+	glBindFramebuffer = (glBindFramebuffer_client_proc_t) getProc("glBindFramebuffer", userData);
+	glBindRenderbuffer = (glBindRenderbuffer_client_proc_t) getProc("glBindRenderbuffer", userData);
+	glBindTexture = (glBindTexture_client_proc_t) getProc("glBindTexture", userData);
+	glBlendColor = (glBlendColor_client_proc_t) getProc("glBlendColor", userData);
+	glBlendEquation = (glBlendEquation_client_proc_t) getProc("glBlendEquation", userData);
+	glBlendEquationSeparate = (glBlendEquationSeparate_client_proc_t) getProc("glBlendEquationSeparate", userData);
+	glBlendFunc = (glBlendFunc_client_proc_t) getProc("glBlendFunc", userData);
+	glBlendFuncSeparate = (glBlendFuncSeparate_client_proc_t) getProc("glBlendFuncSeparate", userData);
+	glBufferData = (glBufferData_client_proc_t) getProc("glBufferData", userData);
+	glBufferSubData = (glBufferSubData_client_proc_t) getProc("glBufferSubData", userData);
+	glCheckFramebufferStatus = (glCheckFramebufferStatus_client_proc_t) getProc("glCheckFramebufferStatus", userData);
+	glClear = (glClear_client_proc_t) getProc("glClear", userData);
+	glClearColor = (glClearColor_client_proc_t) getProc("glClearColor", userData);
+	glClearDepthf = (glClearDepthf_client_proc_t) getProc("glClearDepthf", userData);
+	glClearStencil = (glClearStencil_client_proc_t) getProc("glClearStencil", userData);
+	glColorMask = (glColorMask_client_proc_t) getProc("glColorMask", userData);
+	glCompileShader = (glCompileShader_client_proc_t) getProc("glCompileShader", userData);
+	glCompressedTexImage2D = (glCompressedTexImage2D_client_proc_t) getProc("glCompressedTexImage2D", userData);
+	glCompressedTexSubImage2D = (glCompressedTexSubImage2D_client_proc_t) getProc("glCompressedTexSubImage2D", userData);
+	glCopyTexImage2D = (glCopyTexImage2D_client_proc_t) getProc("glCopyTexImage2D", userData);
+	glCopyTexSubImage2D = (glCopyTexSubImage2D_client_proc_t) getProc("glCopyTexSubImage2D", userData);
+	glCreateProgram = (glCreateProgram_client_proc_t) getProc("glCreateProgram", userData);
+	glCreateShader = (glCreateShader_client_proc_t) getProc("glCreateShader", userData);
+	glCullFace = (glCullFace_client_proc_t) getProc("glCullFace", userData);
+	glDeleteBuffers = (glDeleteBuffers_client_proc_t) getProc("glDeleteBuffers", userData);
+	glDeleteFramebuffers = (glDeleteFramebuffers_client_proc_t) getProc("glDeleteFramebuffers", userData);
+	glDeleteProgram = (glDeleteProgram_client_proc_t) getProc("glDeleteProgram", userData);
+	glDeleteRenderbuffers = (glDeleteRenderbuffers_client_proc_t) getProc("glDeleteRenderbuffers", userData);
+	glDeleteShader = (glDeleteShader_client_proc_t) getProc("glDeleteShader", userData);
+	glDeleteTextures = (glDeleteTextures_client_proc_t) getProc("glDeleteTextures", userData);
+	glDepthFunc = (glDepthFunc_client_proc_t) getProc("glDepthFunc", userData);
+	glDepthMask = (glDepthMask_client_proc_t) getProc("glDepthMask", userData);
+	glDepthRangef = (glDepthRangef_client_proc_t) getProc("glDepthRangef", userData);
+	glDetachShader = (glDetachShader_client_proc_t) getProc("glDetachShader", userData);
+	glDisable = (glDisable_client_proc_t) getProc("glDisable", userData);
+	glDisableVertexAttribArray = (glDisableVertexAttribArray_client_proc_t) getProc("glDisableVertexAttribArray", userData);
+	glDrawArrays = (glDrawArrays_client_proc_t) getProc("glDrawArrays", userData);
+	glDrawElements = (glDrawElements_client_proc_t) getProc("glDrawElements", userData);
+	glEnable = (glEnable_client_proc_t) getProc("glEnable", userData);
+	glEnableVertexAttribArray = (glEnableVertexAttribArray_client_proc_t) getProc("glEnableVertexAttribArray", userData);
+	glFinish = (glFinish_client_proc_t) getProc("glFinish", userData);
+	glFlush = (glFlush_client_proc_t) getProc("glFlush", userData);
+	glFramebufferRenderbuffer = (glFramebufferRenderbuffer_client_proc_t) getProc("glFramebufferRenderbuffer", userData);
+	glFramebufferTexture2D = (glFramebufferTexture2D_client_proc_t) getProc("glFramebufferTexture2D", userData);
+	glFrontFace = (glFrontFace_client_proc_t) getProc("glFrontFace", userData);
+	glGenBuffers = (glGenBuffers_client_proc_t) getProc("glGenBuffers", userData);
+	glGenerateMipmap = (glGenerateMipmap_client_proc_t) getProc("glGenerateMipmap", userData);
+	glGenFramebuffers = (glGenFramebuffers_client_proc_t) getProc("glGenFramebuffers", userData);
+	glGenRenderbuffers = (glGenRenderbuffers_client_proc_t) getProc("glGenRenderbuffers", userData);
+	glGenTextures = (glGenTextures_client_proc_t) getProc("glGenTextures", userData);
+	glGetActiveAttrib = (glGetActiveAttrib_client_proc_t) getProc("glGetActiveAttrib", userData);
+	glGetActiveUniform = (glGetActiveUniform_client_proc_t) getProc("glGetActiveUniform", userData);
+	glGetAttachedShaders = (glGetAttachedShaders_client_proc_t) getProc("glGetAttachedShaders", userData);
+	glGetAttribLocation = (glGetAttribLocation_client_proc_t) getProc("glGetAttribLocation", userData);
+	glGetBooleanv = (glGetBooleanv_client_proc_t) getProc("glGetBooleanv", userData);
+	glGetBufferParameteriv = (glGetBufferParameteriv_client_proc_t) getProc("glGetBufferParameteriv", userData);
+	glGetError = (glGetError_client_proc_t) getProc("glGetError", userData);
+	glGetFloatv = (glGetFloatv_client_proc_t) getProc("glGetFloatv", userData);
+	glGetFramebufferAttachmentParameteriv = (glGetFramebufferAttachmentParameteriv_client_proc_t) getProc("glGetFramebufferAttachmentParameteriv", userData);
+	glGetIntegerv = (glGetIntegerv_client_proc_t) getProc("glGetIntegerv", userData);
+	glGetProgramiv = (glGetProgramiv_client_proc_t) getProc("glGetProgramiv", userData);
+	glGetProgramInfoLog = (glGetProgramInfoLog_client_proc_t) getProc("glGetProgramInfoLog", userData);
+	glGetRenderbufferParameteriv = (glGetRenderbufferParameteriv_client_proc_t) getProc("glGetRenderbufferParameteriv", userData);
+	glGetShaderiv = (glGetShaderiv_client_proc_t) getProc("glGetShaderiv", userData);
+	glGetShaderInfoLog = (glGetShaderInfoLog_client_proc_t) getProc("glGetShaderInfoLog", userData);
+	glGetShaderPrecisionFormat = (glGetShaderPrecisionFormat_client_proc_t) getProc("glGetShaderPrecisionFormat", userData);
+	glGetShaderSource = (glGetShaderSource_client_proc_t) getProc("glGetShaderSource", userData);
+	glGetString = (glGetString_client_proc_t) getProc("glGetString", userData);
+	glGetTexParameterfv = (glGetTexParameterfv_client_proc_t) getProc("glGetTexParameterfv", userData);
+	glGetTexParameteriv = (glGetTexParameteriv_client_proc_t) getProc("glGetTexParameteriv", userData);
+	glGetUniformfv = (glGetUniformfv_client_proc_t) getProc("glGetUniformfv", userData);
+	glGetUniformiv = (glGetUniformiv_client_proc_t) getProc("glGetUniformiv", userData);
+	glGetUniformLocation = (glGetUniformLocation_client_proc_t) getProc("glGetUniformLocation", userData);
+	glGetVertexAttribfv = (glGetVertexAttribfv_client_proc_t) getProc("glGetVertexAttribfv", userData);
+	glGetVertexAttribiv = (glGetVertexAttribiv_client_proc_t) getProc("glGetVertexAttribiv", userData);
+	glGetVertexAttribPointerv = (glGetVertexAttribPointerv_client_proc_t) getProc("glGetVertexAttribPointerv", userData);
+	glHint = (glHint_client_proc_t) getProc("glHint", userData);
+	glIsBuffer = (glIsBuffer_client_proc_t) getProc("glIsBuffer", userData);
+	glIsEnabled = (glIsEnabled_client_proc_t) getProc("glIsEnabled", userData);
+	glIsFramebuffer = (glIsFramebuffer_client_proc_t) getProc("glIsFramebuffer", userData);
+	glIsProgram = (glIsProgram_client_proc_t) getProc("glIsProgram", userData);
+	glIsRenderbuffer = (glIsRenderbuffer_client_proc_t) getProc("glIsRenderbuffer", userData);
+	glIsShader = (glIsShader_client_proc_t) getProc("glIsShader", userData);
+	glIsTexture = (glIsTexture_client_proc_t) getProc("glIsTexture", userData);
+	glLineWidth = (glLineWidth_client_proc_t) getProc("glLineWidth", userData);
+	glLinkProgram = (glLinkProgram_client_proc_t) getProc("glLinkProgram", userData);
+	glPixelStorei = (glPixelStorei_client_proc_t) getProc("glPixelStorei", userData);
+	glPolygonOffset = (glPolygonOffset_client_proc_t) getProc("glPolygonOffset", userData);
+	glReadPixels = (glReadPixels_client_proc_t) getProc("glReadPixels", userData);
+	glReleaseShaderCompiler = (glReleaseShaderCompiler_client_proc_t) getProc("glReleaseShaderCompiler", userData);
+	glRenderbufferStorage = (glRenderbufferStorage_client_proc_t) getProc("glRenderbufferStorage", userData);
+	glSampleCoverage = (glSampleCoverage_client_proc_t) getProc("glSampleCoverage", userData);
+	glScissor = (glScissor_client_proc_t) getProc("glScissor", userData);
+	glShaderBinary = (glShaderBinary_client_proc_t) getProc("glShaderBinary", userData);
+	glShaderSource = (glShaderSource_client_proc_t) getProc("glShaderSource", userData);
+	glStencilFunc = (glStencilFunc_client_proc_t) getProc("glStencilFunc", userData);
+	glStencilFuncSeparate = (glStencilFuncSeparate_client_proc_t) getProc("glStencilFuncSeparate", userData);
+	glStencilMask = (glStencilMask_client_proc_t) getProc("glStencilMask", userData);
+	glStencilMaskSeparate = (glStencilMaskSeparate_client_proc_t) getProc("glStencilMaskSeparate", userData);
+	glStencilOp = (glStencilOp_client_proc_t) getProc("glStencilOp", userData);
+	glStencilOpSeparate = (glStencilOpSeparate_client_proc_t) getProc("glStencilOpSeparate", userData);
+	glTexImage2D = (glTexImage2D_client_proc_t) getProc("glTexImage2D", userData);
+	glTexParameterf = (glTexParameterf_client_proc_t) getProc("glTexParameterf", userData);
+	glTexParameterfv = (glTexParameterfv_client_proc_t) getProc("glTexParameterfv", userData);
+	glTexParameteri = (glTexParameteri_client_proc_t) getProc("glTexParameteri", userData);
+	glTexParameteriv = (glTexParameteriv_client_proc_t) getProc("glTexParameteriv", userData);
+	glTexSubImage2D = (glTexSubImage2D_client_proc_t) getProc("glTexSubImage2D", userData);
+	glUniform1f = (glUniform1f_client_proc_t) getProc("glUniform1f", userData);
+	glUniform1fv = (glUniform1fv_client_proc_t) getProc("glUniform1fv", userData);
+	glUniform1i = (glUniform1i_client_proc_t) getProc("glUniform1i", userData);
+	glUniform1iv = (glUniform1iv_client_proc_t) getProc("glUniform1iv", userData);
+	glUniform2f = (glUniform2f_client_proc_t) getProc("glUniform2f", userData);
+	glUniform2fv = (glUniform2fv_client_proc_t) getProc("glUniform2fv", userData);
+	glUniform2i = (glUniform2i_client_proc_t) getProc("glUniform2i", userData);
+	glUniform2iv = (glUniform2iv_client_proc_t) getProc("glUniform2iv", userData);
+	glUniform3f = (glUniform3f_client_proc_t) getProc("glUniform3f", userData);
+	glUniform3fv = (glUniform3fv_client_proc_t) getProc("glUniform3fv", userData);
+	glUniform3i = (glUniform3i_client_proc_t) getProc("glUniform3i", userData);
+	glUniform3iv = (glUniform3iv_client_proc_t) getProc("glUniform3iv", userData);
+	glUniform4f = (glUniform4f_client_proc_t) getProc("glUniform4f", userData);
+	glUniform4fv = (glUniform4fv_client_proc_t) getProc("glUniform4fv", userData);
+	glUniform4i = (glUniform4i_client_proc_t) getProc("glUniform4i", userData);
+	glUniform4iv = (glUniform4iv_client_proc_t) getProc("glUniform4iv", userData);
+	glUniformMatrix2fv = (glUniformMatrix2fv_client_proc_t) getProc("glUniformMatrix2fv", userData);
+	glUniformMatrix3fv = (glUniformMatrix3fv_client_proc_t) getProc("glUniformMatrix3fv", userData);
+	glUniformMatrix4fv = (glUniformMatrix4fv_client_proc_t) getProc("glUniformMatrix4fv", userData);
+	glUseProgram = (glUseProgram_client_proc_t) getProc("glUseProgram", userData);
+	glValidateProgram = (glValidateProgram_client_proc_t) getProc("glValidateProgram", userData);
+	glVertexAttrib1f = (glVertexAttrib1f_client_proc_t) getProc("glVertexAttrib1f", userData);
+	glVertexAttrib1fv = (glVertexAttrib1fv_client_proc_t) getProc("glVertexAttrib1fv", userData);
+	glVertexAttrib2f = (glVertexAttrib2f_client_proc_t) getProc("glVertexAttrib2f", userData);
+	glVertexAttrib2fv = (glVertexAttrib2fv_client_proc_t) getProc("glVertexAttrib2fv", userData);
+	glVertexAttrib3f = (glVertexAttrib3f_client_proc_t) getProc("glVertexAttrib3f", userData);
+	glVertexAttrib3fv = (glVertexAttrib3fv_client_proc_t) getProc("glVertexAttrib3fv", userData);
+	glVertexAttrib4f = (glVertexAttrib4f_client_proc_t) getProc("glVertexAttrib4f", userData);
+	glVertexAttrib4fv = (glVertexAttrib4fv_client_proc_t) getProc("glVertexAttrib4fv", userData);
+	glVertexAttribPointer = (glVertexAttribPointer_client_proc_t) getProc("glVertexAttribPointer", userData);
+	glViewport = (glViewport_client_proc_t) getProc("glViewport", userData);
+	glEGLImageTargetTexture2DOES = (glEGLImageTargetTexture2DOES_client_proc_t) getProc("glEGLImageTargetTexture2DOES", userData);
+	glEGLImageTargetRenderbufferStorageOES = (glEGLImageTargetRenderbufferStorageOES_client_proc_t) getProc("glEGLImageTargetRenderbufferStorageOES", userData);
+	glGetProgramBinaryOES = (glGetProgramBinaryOES_client_proc_t) getProc("glGetProgramBinaryOES", userData);
+	glProgramBinaryOES = (glProgramBinaryOES_client_proc_t) getProc("glProgramBinaryOES", userData);
+	glMapBufferOES = (glMapBufferOES_client_proc_t) getProc("glMapBufferOES", userData);
+	glUnmapBufferOES = (glUnmapBufferOES_client_proc_t) getProc("glUnmapBufferOES", userData);
+	glTexImage3DOES = (glTexImage3DOES_client_proc_t) getProc("glTexImage3DOES", userData);
+	glTexSubImage3DOES = (glTexSubImage3DOES_client_proc_t) getProc("glTexSubImage3DOES", userData);
+	glCopyTexSubImage3DOES = (glCopyTexSubImage3DOES_client_proc_t) getProc("glCopyTexSubImage3DOES", userData);
+	glCompressedTexImage3DOES = (glCompressedTexImage3DOES_client_proc_t) getProc("glCompressedTexImage3DOES", userData);
+	glCompressedTexSubImage3DOES = (glCompressedTexSubImage3DOES_client_proc_t) getProc("glCompressedTexSubImage3DOES", userData);
+	glFramebufferTexture3DOES = (glFramebufferTexture3DOES_client_proc_t) getProc("glFramebufferTexture3DOES", userData);
+	glBindVertexArrayOES = (glBindVertexArrayOES_client_proc_t) getProc("glBindVertexArrayOES", userData);
+	glDeleteVertexArraysOES = (glDeleteVertexArraysOES_client_proc_t) getProc("glDeleteVertexArraysOES", userData);
+	glGenVertexArraysOES = (glGenVertexArraysOES_client_proc_t) getProc("glGenVertexArraysOES", userData);
+	glIsVertexArrayOES = (glIsVertexArrayOES_client_proc_t) getProc("glIsVertexArrayOES", userData);
+	glDiscardFramebufferEXT = (glDiscardFramebufferEXT_client_proc_t) getProc("glDiscardFramebufferEXT", userData);
+	glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) getProc("glMultiDrawArraysEXT", userData);
+	glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) getProc("glMultiDrawElementsEXT", userData);
+	glGetPerfMonitorGroupsAMD = (glGetPerfMonitorGroupsAMD_client_proc_t) getProc("glGetPerfMonitorGroupsAMD", userData);
+	glGetPerfMonitorCountersAMD = (glGetPerfMonitorCountersAMD_client_proc_t) getProc("glGetPerfMonitorCountersAMD", userData);
+	glGetPerfMonitorGroupStringAMD = (glGetPerfMonitorGroupStringAMD_client_proc_t) getProc("glGetPerfMonitorGroupStringAMD", userData);
+	glGetPerfMonitorCounterStringAMD = (glGetPerfMonitorCounterStringAMD_client_proc_t) getProc("glGetPerfMonitorCounterStringAMD", userData);
+	glGetPerfMonitorCounterInfoAMD = (glGetPerfMonitorCounterInfoAMD_client_proc_t) getProc("glGetPerfMonitorCounterInfoAMD", userData);
+	glGenPerfMonitorsAMD = (glGenPerfMonitorsAMD_client_proc_t) getProc("glGenPerfMonitorsAMD", userData);
+	glDeletePerfMonitorsAMD = (glDeletePerfMonitorsAMD_client_proc_t) getProc("glDeletePerfMonitorsAMD", userData);
+	glSelectPerfMonitorCountersAMD = (glSelectPerfMonitorCountersAMD_client_proc_t) getProc("glSelectPerfMonitorCountersAMD", userData);
+	glBeginPerfMonitorAMD = (glBeginPerfMonitorAMD_client_proc_t) getProc("glBeginPerfMonitorAMD", userData);
+	glEndPerfMonitorAMD = (glEndPerfMonitorAMD_client_proc_t) getProc("glEndPerfMonitorAMD", userData);
+	glGetPerfMonitorCounterDataAMD = (glGetPerfMonitorCounterDataAMD_client_proc_t) getProc("glGetPerfMonitorCounterDataAMD", userData);
+	glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) getProc("glRenderbufferStorageMultisampleIMG", userData);
+	glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) getProc("glFramebufferTexture2DMultisampleIMG", userData);
+	glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) getProc("glDeleteFencesNV", userData);
+	glGenFencesNV = (glGenFencesNV_client_proc_t) getProc("glGenFencesNV", userData);
+	glIsFenceNV = (glIsFenceNV_client_proc_t) getProc("glIsFenceNV", userData);
+	glTestFenceNV = (glTestFenceNV_client_proc_t) getProc("glTestFenceNV", userData);
+	glGetFenceivNV = (glGetFenceivNV_client_proc_t) getProc("glGetFenceivNV", userData);
+	glFinishFenceNV = (glFinishFenceNV_client_proc_t) getProc("glFinishFenceNV", userData);
+	glSetFenceNV = (glSetFenceNV_client_proc_t) getProc("glSetFenceNV", userData);
+	glCoverageMaskNV = (glCoverageMaskNV_client_proc_t) getProc("glCoverageMaskNV", userData);
+	glCoverageOperationNV = (glCoverageOperationNV_client_proc_t) getProc("glCoverageOperationNV", userData);
+	glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) getProc("glGetDriverControlsQCOM", userData);
+	glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) getProc("glGetDriverControlStringQCOM", userData);
+	glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) getProc("glEnableDriverControlQCOM", userData);
+	glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) getProc("glDisableDriverControlQCOM", userData);
+	glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) getProc("glExtGetTexturesQCOM", userData);
+	glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) getProc("glExtGetBuffersQCOM", userData);
+	glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) getProc("glExtGetRenderbuffersQCOM", userData);
+	glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) getProc("glExtGetFramebuffersQCOM", userData);
+	glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) getProc("glExtGetTexLevelParameterivQCOM", userData);
+	glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) getProc("glExtTexObjectStateOverrideiQCOM", userData);
+	glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) getProc("glExtGetTexSubImageQCOM", userData);
+	glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) getProc("glExtGetBufferPointervQCOM", userData);
+	glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) getProc("glExtGetShadersQCOM", userData);
+	glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) getProc("glExtGetProgramsQCOM", userData);
+	glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) getProc("glExtIsProgramBinaryQCOM", userData);
+	glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) getProc("glExtGetProgramBinarySourceQCOM", userData);
+	glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) getProc("glStartTilingQCOM", userData);
+	glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) getProc("glEndTilingQCOM", userData);
+	glVertexAttribPointerData = (glVertexAttribPointerData_client_proc_t) getProc("glVertexAttribPointerData", userData);
+	glVertexAttribPointerOffset = (glVertexAttribPointerOffset_client_proc_t) getProc("glVertexAttribPointerOffset", userData);
+	glDrawElementsOffset = (glDrawElementsOffset_client_proc_t) getProc("glDrawElementsOffset", userData);
+	glDrawElementsData = (glDrawElementsData_client_proc_t) getProc("glDrawElementsData", userData);
+	glGetCompressedTextureFormats = (glGetCompressedTextureFormats_client_proc_t) getProc("glGetCompressedTextureFormats", userData);
+	glShaderString = (glShaderString_client_proc_t) getProc("glShaderString", userData);
+	glFinishRoundTrip = (glFinishRoundTrip_client_proc_t) getProc("glFinishRoundTrip", userData);
 	return 0;
 }
 
diff --git a/opengl/system/GLESv2_enc/gl2_client_context.h b/opengl/system/GLESv2_enc/gl2_client_context.h
index 7f0abcd..87d62d5 100644
--- a/opengl/system/GLESv2_enc/gl2_client_context.h
+++ b/opengl/system/GLESv2_enc/gl2_client_context.h
@@ -216,221 +216,12 @@ struct gl2_client_context_t {
 	glGetCompressedTextureFormats_client_proc_t glGetCompressedTextureFormats;
 	glShaderString_client_proc_t glShaderString;
 	glFinishRoundTrip_client_proc_t glFinishRoundTrip;
-	//Accessors 
-	virtual glActiveTexture_client_proc_t set_glActiveTexture(glActiveTexture_client_proc_t f) { glActiveTexture_client_proc_t retval = glActiveTexture; glActiveTexture = f; return retval;}
-	virtual glAttachShader_client_proc_t set_glAttachShader(glAttachShader_client_proc_t f) { glAttachShader_client_proc_t retval = glAttachShader; glAttachShader = f; return retval;}
-	virtual glBindAttribLocation_client_proc_t set_glBindAttribLocation(glBindAttribLocation_client_proc_t f) { glBindAttribLocation_client_proc_t retval = glBindAttribLocation; glBindAttribLocation = f; return retval;}
-	virtual glBindBuffer_client_proc_t set_glBindBuffer(glBindBuffer_client_proc_t f) { glBindBuffer_client_proc_t retval = glBindBuffer; glBindBuffer = f; return retval;}
-	virtual glBindFramebuffer_client_proc_t set_glBindFramebuffer(glBindFramebuffer_client_proc_t f) { glBindFramebuffer_client_proc_t retval = glBindFramebuffer; glBindFramebuffer = f; return retval;}
-	virtual glBindRenderbuffer_client_proc_t set_glBindRenderbuffer(glBindRenderbuffer_client_proc_t f) { glBindRenderbuffer_client_proc_t retval = glBindRenderbuffer; glBindRenderbuffer = f; return retval;}
-	virtual glBindTexture_client_proc_t set_glBindTexture(glBindTexture_client_proc_t f) { glBindTexture_client_proc_t retval = glBindTexture; glBindTexture = f; return retval;}
-	virtual glBlendColor_client_proc_t set_glBlendColor(glBlendColor_client_proc_t f) { glBlendColor_client_proc_t retval = glBlendColor; glBlendColor = f; return retval;}
-	virtual glBlendEquation_client_proc_t set_glBlendEquation(glBlendEquation_client_proc_t f) { glBlendEquation_client_proc_t retval = glBlendEquation; glBlendEquation = f; return retval;}
-	virtual glBlendEquationSeparate_client_proc_t set_glBlendEquationSeparate(glBlendEquationSeparate_client_proc_t f) { glBlendEquationSeparate_client_proc_t retval = glBlendEquationSeparate; glBlendEquationSeparate = f; return retval;}
-	virtual glBlendFunc_client_proc_t set_glBlendFunc(glBlendFunc_client_proc_t f) { glBlendFunc_client_proc_t retval = glBlendFunc; glBlendFunc = f; return retval;}
-	virtual glBlendFuncSeparate_client_proc_t set_glBlendFuncSeparate(glBlendFuncSeparate_client_proc_t f) { glBlendFuncSeparate_client_proc_t retval = glBlendFuncSeparate; glBlendFuncSeparate = f; return retval;}
-	virtual glBufferData_client_proc_t set_glBufferData(glBufferData_client_proc_t f) { glBufferData_client_proc_t retval = glBufferData; glBufferData = f; return retval;}
-	virtual glBufferSubData_client_proc_t set_glBufferSubData(glBufferSubData_client_proc_t f) { glBufferSubData_client_proc_t retval = glBufferSubData; glBufferSubData = f; return retval;}
-	virtual glCheckFramebufferStatus_client_proc_t set_glCheckFramebufferStatus(glCheckFramebufferStatus_client_proc_t f) { glCheckFramebufferStatus_client_proc_t retval = glCheckFramebufferStatus; glCheckFramebufferStatus = f; return retval;}
-	virtual glClear_client_proc_t set_glClear(glClear_client_proc_t f) { glClear_client_proc_t retval = glClear; glClear = f; return retval;}
-	virtual glClearColor_client_proc_t set_glClearColor(glClearColor_client_proc_t f) { glClearColor_client_proc_t retval = glClearColor; glClearColor = f; return retval;}
-	virtual glClearDepthf_client_proc_t set_glClearDepthf(glClearDepthf_client_proc_t f) { glClearDepthf_client_proc_t retval = glClearDepthf; glClearDepthf = f; return retval;}
-	virtual glClearStencil_client_proc_t set_glClearStencil(glClearStencil_client_proc_t f) { glClearStencil_client_proc_t retval = glClearStencil; glClearStencil = f; return retval;}
-	virtual glColorMask_client_proc_t set_glColorMask(glColorMask_client_proc_t f) { glColorMask_client_proc_t retval = glColorMask; glColorMask = f; return retval;}
-	virtual glCompileShader_client_proc_t set_glCompileShader(glCompileShader_client_proc_t f) { glCompileShader_client_proc_t retval = glCompileShader; glCompileShader = f; return retval;}
-	virtual glCompressedTexImage2D_client_proc_t set_glCompressedTexImage2D(glCompressedTexImage2D_client_proc_t f) { glCompressedTexImage2D_client_proc_t retval = glCompressedTexImage2D; glCompressedTexImage2D = f; return retval;}
-	virtual glCompressedTexSubImage2D_client_proc_t set_glCompressedTexSubImage2D(glCompressedTexSubImage2D_client_proc_t f) { glCompressedTexSubImage2D_client_proc_t retval = glCompressedTexSubImage2D; glCompressedTexSubImage2D = f; return retval;}
-	virtual glCopyTexImage2D_client_proc_t set_glCopyTexImage2D(glCopyTexImage2D_client_proc_t f) { glCopyTexImage2D_client_proc_t retval = glCopyTexImage2D; glCopyTexImage2D = f; return retval;}
-	virtual glCopyTexSubImage2D_client_proc_t set_glCopyTexSubImage2D(glCopyTexSubImage2D_client_proc_t f) { glCopyTexSubImage2D_client_proc_t retval = glCopyTexSubImage2D; glCopyTexSubImage2D = f; return retval;}
-	virtual glCreateProgram_client_proc_t set_glCreateProgram(glCreateProgram_client_proc_t f) { glCreateProgram_client_proc_t retval = glCreateProgram; glCreateProgram = f; return retval;}
-	virtual glCreateShader_client_proc_t set_glCreateShader(glCreateShader_client_proc_t f) { glCreateShader_client_proc_t retval = glCreateShader; glCreateShader = f; return retval;}
-	virtual glCullFace_client_proc_t set_glCullFace(glCullFace_client_proc_t f) { glCullFace_client_proc_t retval = glCullFace; glCullFace = f; return retval;}
-	virtual glDeleteBuffers_client_proc_t set_glDeleteBuffers(glDeleteBuffers_client_proc_t f) { glDeleteBuffers_client_proc_t retval = glDeleteBuffers; glDeleteBuffers = f; return retval;}
-	virtual glDeleteFramebuffers_client_proc_t set_glDeleteFramebuffers(glDeleteFramebuffers_client_proc_t f) { glDeleteFramebuffers_client_proc_t retval = glDeleteFramebuffers; glDeleteFramebuffers = f; return retval;}
-	virtual glDeleteProgram_client_proc_t set_glDeleteProgram(glDeleteProgram_client_proc_t f) { glDeleteProgram_client_proc_t retval = glDeleteProgram; glDeleteProgram = f; return retval;}
-	virtual glDeleteRenderbuffers_client_proc_t set_glDeleteRenderbuffers(glDeleteRenderbuffers_client_proc_t f) { glDeleteRenderbuffers_client_proc_t retval = glDeleteRenderbuffers; glDeleteRenderbuffers = f; return retval;}
-	virtual glDeleteShader_client_proc_t set_glDeleteShader(glDeleteShader_client_proc_t f) { glDeleteShader_client_proc_t retval = glDeleteShader; glDeleteShader = f; return retval;}
-	virtual glDeleteTextures_client_proc_t set_glDeleteTextures(glDeleteTextures_client_proc_t f) { glDeleteTextures_client_proc_t retval = glDeleteTextures; glDeleteTextures = f; return retval;}
-	virtual glDepthFunc_client_proc_t set_glDepthFunc(glDepthFunc_client_proc_t f) { glDepthFunc_client_proc_t retval = glDepthFunc; glDepthFunc = f; return retval;}
-	virtual glDepthMask_client_proc_t set_glDepthMask(glDepthMask_client_proc_t f) { glDepthMask_client_proc_t retval = glDepthMask; glDepthMask = f; return retval;}
-	virtual glDepthRangef_client_proc_t set_glDepthRangef(glDepthRangef_client_proc_t f) { glDepthRangef_client_proc_t retval = glDepthRangef; glDepthRangef = f; return retval;}
-	virtual glDetachShader_client_proc_t set_glDetachShader(glDetachShader_client_proc_t f) { glDetachShader_client_proc_t retval = glDetachShader; glDetachShader = f; return retval;}
-	virtual glDisable_client_proc_t set_glDisable(glDisable_client_proc_t f) { glDisable_client_proc_t retval = glDisable; glDisable = f; return retval;}
-	virtual glDisableVertexAttribArray_client_proc_t set_glDisableVertexAttribArray(glDisableVertexAttribArray_client_proc_t f) { glDisableVertexAttribArray_client_proc_t retval = glDisableVertexAttribArray; glDisableVertexAttribArray = f; return retval;}
-	virtual glDrawArrays_client_proc_t set_glDrawArrays(glDrawArrays_client_proc_t f) { glDrawArrays_client_proc_t retval = glDrawArrays; glDrawArrays = f; return retval;}
-	virtual glDrawElements_client_proc_t set_glDrawElements(glDrawElements_client_proc_t f) { glDrawElements_client_proc_t retval = glDrawElements; glDrawElements = f; return retval;}
-	virtual glEnable_client_proc_t set_glEnable(glEnable_client_proc_t f) { glEnable_client_proc_t retval = glEnable; glEnable = f; return retval;}
-	virtual glEnableVertexAttribArray_client_proc_t set_glEnableVertexAttribArray(glEnableVertexAttribArray_client_proc_t f) { glEnableVertexAttribArray_client_proc_t retval = glEnableVertexAttribArray; glEnableVertexAttribArray = f; return retval;}
-	virtual glFinish_client_proc_t set_glFinish(glFinish_client_proc_t f) { glFinish_client_proc_t retval = glFinish; glFinish = f; return retval;}
-	virtual glFlush_client_proc_t set_glFlush(glFlush_client_proc_t f) { glFlush_client_proc_t retval = glFlush; glFlush = f; return retval;}
-	virtual glFramebufferRenderbuffer_client_proc_t set_glFramebufferRenderbuffer(glFramebufferRenderbuffer_client_proc_t f) { glFramebufferRenderbuffer_client_proc_t retval = glFramebufferRenderbuffer; glFramebufferRenderbuffer = f; return retval;}
-	virtual glFramebufferTexture2D_client_proc_t set_glFramebufferTexture2D(glFramebufferTexture2D_client_proc_t f) { glFramebufferTexture2D_client_proc_t retval = glFramebufferTexture2D; glFramebufferTexture2D = f; return retval;}
-	virtual glFrontFace_client_proc_t set_glFrontFace(glFrontFace_client_proc_t f) { glFrontFace_client_proc_t retval = glFrontFace; glFrontFace = f; return retval;}
-	virtual glGenBuffers_client_proc_t set_glGenBuffers(glGenBuffers_client_proc_t f) { glGenBuffers_client_proc_t retval = glGenBuffers; glGenBuffers = f; return retval;}
-	virtual glGenerateMipmap_client_proc_t set_glGenerateMipmap(glGenerateMipmap_client_proc_t f) { glGenerateMipmap_client_proc_t retval = glGenerateMipmap; glGenerateMipmap = f; return retval;}
-	virtual glGenFramebuffers_client_proc_t set_glGenFramebuffers(glGenFramebuffers_client_proc_t f) { glGenFramebuffers_client_proc_t retval = glGenFramebuffers; glGenFramebuffers = f; return retval;}
-	virtual glGenRenderbuffers_client_proc_t set_glGenRenderbuffers(glGenRenderbuffers_client_proc_t f) { glGenRenderbuffers_client_proc_t retval = glGenRenderbuffers; glGenRenderbuffers = f; return retval;}
-	virtual glGenTextures_client_proc_t set_glGenTextures(glGenTextures_client_proc_t f) { glGenTextures_client_proc_t retval = glGenTextures; glGenTextures = f; return retval;}
-	virtual glGetActiveAttrib_client_proc_t set_glGetActiveAttrib(glGetActiveAttrib_client_proc_t f) { glGetActiveAttrib_client_proc_t retval = glGetActiveAttrib; glGetActiveAttrib = f; return retval;}
-	virtual glGetActiveUniform_client_proc_t set_glGetActiveUniform(glGetActiveUniform_client_proc_t f) { glGetActiveUniform_client_proc_t retval = glGetActiveUniform; glGetActiveUniform = f; return retval;}
-	virtual glGetAttachedShaders_client_proc_t set_glGetAttachedShaders(glGetAttachedShaders_client_proc_t f) { glGetAttachedShaders_client_proc_t retval = glGetAttachedShaders; glGetAttachedShaders = f; return retval;}
-	virtual glGetAttribLocation_client_proc_t set_glGetAttribLocation(glGetAttribLocation_client_proc_t f) { glGetAttribLocation_client_proc_t retval = glGetAttribLocation; glGetAttribLocation = f; return retval;}
-	virtual glGetBooleanv_client_proc_t set_glGetBooleanv(glGetBooleanv_client_proc_t f) { glGetBooleanv_client_proc_t retval = glGetBooleanv; glGetBooleanv = f; return retval;}
-	virtual glGetBufferParameteriv_client_proc_t set_glGetBufferParameteriv(glGetBufferParameteriv_client_proc_t f) { glGetBufferParameteriv_client_proc_t retval = glGetBufferParameteriv; glGetBufferParameteriv = f; return retval;}
-	virtual glGetError_client_proc_t set_glGetError(glGetError_client_proc_t f) { glGetError_client_proc_t retval = glGetError; glGetError = f; return retval;}
-	virtual glGetFloatv_client_proc_t set_glGetFloatv(glGetFloatv_client_proc_t f) { glGetFloatv_client_proc_t retval = glGetFloatv; glGetFloatv = f; return retval;}
-	virtual glGetFramebufferAttachmentParameteriv_client_proc_t set_glGetFramebufferAttachmentParameteriv(glGetFramebufferAttachmentParameteriv_client_proc_t f) { glGetFramebufferAttachmentParameteriv_client_proc_t retval = glGetFramebufferAttachmentParameteriv; glGetFramebufferAttachmentParameteriv = f; return retval;}
-	virtual glGetIntegerv_client_proc_t set_glGetIntegerv(glGetIntegerv_client_proc_t f) { glGetIntegerv_client_proc_t retval = glGetIntegerv; glGetIntegerv = f; return retval;}
-	virtual glGetProgramiv_client_proc_t set_glGetProgramiv(glGetProgramiv_client_proc_t f) { glGetProgramiv_client_proc_t retval = glGetProgramiv; glGetProgramiv = f; return retval;}
-	virtual glGetProgramInfoLog_client_proc_t set_glGetProgramInfoLog(glGetProgramInfoLog_client_proc_t f) { glGetProgramInfoLog_client_proc_t retval = glGetProgramInfoLog; glGetProgramInfoLog = f; return retval;}
-	virtual glGetRenderbufferParameteriv_client_proc_t set_glGetRenderbufferParameteriv(glGetRenderbufferParameteriv_client_proc_t f) { glGetRenderbufferParameteriv_client_proc_t retval = glGetRenderbufferParameteriv; glGetRenderbufferParameteriv = f; return retval;}
-	virtual glGetShaderiv_client_proc_t set_glGetShaderiv(glGetShaderiv_client_proc_t f) { glGetShaderiv_client_proc_t retval = glGetShaderiv; glGetShaderiv = f; return retval;}
-	virtual glGetShaderInfoLog_client_proc_t set_glGetShaderInfoLog(glGetShaderInfoLog_client_proc_t f) { glGetShaderInfoLog_client_proc_t retval = glGetShaderInfoLog; glGetShaderInfoLog = f; return retval;}
-	virtual glGetShaderPrecisionFormat_client_proc_t set_glGetShaderPrecisionFormat(glGetShaderPrecisionFormat_client_proc_t f) { glGetShaderPrecisionFormat_client_proc_t retval = glGetShaderPrecisionFormat; glGetShaderPrecisionFormat = f; return retval;}
-	virtual glGetShaderSource_client_proc_t set_glGetShaderSource(glGetShaderSource_client_proc_t f) { glGetShaderSource_client_proc_t retval = glGetShaderSource; glGetShaderSource = f; return retval;}
-	virtual glGetString_client_proc_t set_glGetString(glGetString_client_proc_t f) { glGetString_client_proc_t retval = glGetString; glGetString = f; return retval;}
-	virtual glGetTexParameterfv_client_proc_t set_glGetTexParameterfv(glGetTexParameterfv_client_proc_t f) { glGetTexParameterfv_client_proc_t retval = glGetTexParameterfv; glGetTexParameterfv = f; return retval;}
-	virtual glGetTexParameteriv_client_proc_t set_glGetTexParameteriv(glGetTexParameteriv_client_proc_t f) { glGetTexParameteriv_client_proc_t retval = glGetTexParameteriv; glGetTexParameteriv = f; return retval;}
-	virtual glGetUniformfv_client_proc_t set_glGetUniformfv(glGetUniformfv_client_proc_t f) { glGetUniformfv_client_proc_t retval = glGetUniformfv; glGetUniformfv = f; return retval;}
-	virtual glGetUniformiv_client_proc_t set_glGetUniformiv(glGetUniformiv_client_proc_t f) { glGetUniformiv_client_proc_t retval = glGetUniformiv; glGetUniformiv = f; return retval;}
-	virtual glGetUniformLocation_client_proc_t set_glGetUniformLocation(glGetUniformLocation_client_proc_t f) { glGetUniformLocation_client_proc_t retval = glGetUniformLocation; glGetUniformLocation = f; return retval;}
-	virtual glGetVertexAttribfv_client_proc_t set_glGetVertexAttribfv(glGetVertexAttribfv_client_proc_t f) { glGetVertexAttribfv_client_proc_t retval = glGetVertexAttribfv; glGetVertexAttribfv = f; return retval;}
-	virtual glGetVertexAttribiv_client_proc_t set_glGetVertexAttribiv(glGetVertexAttribiv_client_proc_t f) { glGetVertexAttribiv_client_proc_t retval = glGetVertexAttribiv; glGetVertexAttribiv = f; return retval;}
-	virtual glGetVertexAttribPointerv_client_proc_t set_glGetVertexAttribPointerv(glGetVertexAttribPointerv_client_proc_t f) { glGetVertexAttribPointerv_client_proc_t retval = glGetVertexAttribPointerv; glGetVertexAttribPointerv = f; return retval;}
-	virtual glHint_client_proc_t set_glHint(glHint_client_proc_t f) { glHint_client_proc_t retval = glHint; glHint = f; return retval;}
-	virtual glIsBuffer_client_proc_t set_glIsBuffer(glIsBuffer_client_proc_t f) { glIsBuffer_client_proc_t retval = glIsBuffer; glIsBuffer = f; return retval;}
-	virtual glIsEnabled_client_proc_t set_glIsEnabled(glIsEnabled_client_proc_t f) { glIsEnabled_client_proc_t retval = glIsEnabled; glIsEnabled = f; return retval;}
-	virtual glIsFramebuffer_client_proc_t set_glIsFramebuffer(glIsFramebuffer_client_proc_t f) { glIsFramebuffer_client_proc_t retval = glIsFramebuffer; glIsFramebuffer = f; return retval;}
-	virtual glIsProgram_client_proc_t set_glIsProgram(glIsProgram_client_proc_t f) { glIsProgram_client_proc_t retval = glIsProgram; glIsProgram = f; return retval;}
-	virtual glIsRenderbuffer_client_proc_t set_glIsRenderbuffer(glIsRenderbuffer_client_proc_t f) { glIsRenderbuffer_client_proc_t retval = glIsRenderbuffer; glIsRenderbuffer = f; return retval;}
-	virtual glIsShader_client_proc_t set_glIsShader(glIsShader_client_proc_t f) { glIsShader_client_proc_t retval = glIsShader; glIsShader = f; return retval;}
-	virtual glIsTexture_client_proc_t set_glIsTexture(glIsTexture_client_proc_t f) { glIsTexture_client_proc_t retval = glIsTexture; glIsTexture = f; return retval;}
-	virtual glLineWidth_client_proc_t set_glLineWidth(glLineWidth_client_proc_t f) { glLineWidth_client_proc_t retval = glLineWidth; glLineWidth = f; return retval;}
-	virtual glLinkProgram_client_proc_t set_glLinkProgram(glLinkProgram_client_proc_t f) { glLinkProgram_client_proc_t retval = glLinkProgram; glLinkProgram = f; return retval;}
-	virtual glPixelStorei_client_proc_t set_glPixelStorei(glPixelStorei_client_proc_t f) { glPixelStorei_client_proc_t retval = glPixelStorei; glPixelStorei = f; return retval;}
-	virtual glPolygonOffset_client_proc_t set_glPolygonOffset(glPolygonOffset_client_proc_t f) { glPolygonOffset_client_proc_t retval = glPolygonOffset; glPolygonOffset = f; return retval;}
-	virtual glReadPixels_client_proc_t set_glReadPixels(glReadPixels_client_proc_t f) { glReadPixels_client_proc_t retval = glReadPixels; glReadPixels = f; return retval;}
-	virtual glReleaseShaderCompiler_client_proc_t set_glReleaseShaderCompiler(glReleaseShaderCompiler_client_proc_t f) { glReleaseShaderCompiler_client_proc_t retval = glReleaseShaderCompiler; glReleaseShaderCompiler = f; return retval;}
-	virtual glRenderbufferStorage_client_proc_t set_glRenderbufferStorage(glRenderbufferStorage_client_proc_t f) { glRenderbufferStorage_client_proc_t retval = glRenderbufferStorage; glRenderbufferStorage = f; return retval;}
-	virtual glSampleCoverage_client_proc_t set_glSampleCoverage(glSampleCoverage_client_proc_t f) { glSampleCoverage_client_proc_t retval = glSampleCoverage; glSampleCoverage = f; return retval;}
-	virtual glScissor_client_proc_t set_glScissor(glScissor_client_proc_t f) { glScissor_client_proc_t retval = glScissor; glScissor = f; return retval;}
-	virtual glShaderBinary_client_proc_t set_glShaderBinary(glShaderBinary_client_proc_t f) { glShaderBinary_client_proc_t retval = glShaderBinary; glShaderBinary = f; return retval;}
-	virtual glShaderSource_client_proc_t set_glShaderSource(glShaderSource_client_proc_t f) { glShaderSource_client_proc_t retval = glShaderSource; glShaderSource = f; return retval;}
-	virtual glStencilFunc_client_proc_t set_glStencilFunc(glStencilFunc_client_proc_t f) { glStencilFunc_client_proc_t retval = glStencilFunc; glStencilFunc = f; return retval;}
-	virtual glStencilFuncSeparate_client_proc_t set_glStencilFuncSeparate(glStencilFuncSeparate_client_proc_t f) { glStencilFuncSeparate_client_proc_t retval = glStencilFuncSeparate; glStencilFuncSeparate = f; return retval;}
-	virtual glStencilMask_client_proc_t set_glStencilMask(glStencilMask_client_proc_t f) { glStencilMask_client_proc_t retval = glStencilMask; glStencilMask = f; return retval;}
-	virtual glStencilMaskSeparate_client_proc_t set_glStencilMaskSeparate(glStencilMaskSeparate_client_proc_t f) { glStencilMaskSeparate_client_proc_t retval = glStencilMaskSeparate; glStencilMaskSeparate = f; return retval;}
-	virtual glStencilOp_client_proc_t set_glStencilOp(glStencilOp_client_proc_t f) { glStencilOp_client_proc_t retval = glStencilOp; glStencilOp = f; return retval;}
-	virtual glStencilOpSeparate_client_proc_t set_glStencilOpSeparate(glStencilOpSeparate_client_proc_t f) { glStencilOpSeparate_client_proc_t retval = glStencilOpSeparate; glStencilOpSeparate = f; return retval;}
-	virtual glTexImage2D_client_proc_t set_glTexImage2D(glTexImage2D_client_proc_t f) { glTexImage2D_client_proc_t retval = glTexImage2D; glTexImage2D = f; return retval;}
-	virtual glTexParameterf_client_proc_t set_glTexParameterf(glTexParameterf_client_proc_t f) { glTexParameterf_client_proc_t retval = glTexParameterf; glTexParameterf = f; return retval;}
-	virtual glTexParameterfv_client_proc_t set_glTexParameterfv(glTexParameterfv_client_proc_t f) { glTexParameterfv_client_proc_t retval = glTexParameterfv; glTexParameterfv = f; return retval;}
-	virtual glTexParameteri_client_proc_t set_glTexParameteri(glTexParameteri_client_proc_t f) { glTexParameteri_client_proc_t retval = glTexParameteri; glTexParameteri = f; return retval;}
-	virtual glTexParameteriv_client_proc_t set_glTexParameteriv(glTexParameteriv_client_proc_t f) { glTexParameteriv_client_proc_t retval = glTexParameteriv; glTexParameteriv = f; return retval;}
-	virtual glTexSubImage2D_client_proc_t set_glTexSubImage2D(glTexSubImage2D_client_proc_t f) { glTexSubImage2D_client_proc_t retval = glTexSubImage2D; glTexSubImage2D = f; return retval;}
-	virtual glUniform1f_client_proc_t set_glUniform1f(glUniform1f_client_proc_t f) { glUniform1f_client_proc_t retval = glUniform1f; glUniform1f = f; return retval;}
-	virtual glUniform1fv_client_proc_t set_glUniform1fv(glUniform1fv_client_proc_t f) { glUniform1fv_client_proc_t retval = glUniform1fv; glUniform1fv = f; return retval;}
-	virtual glUniform1i_client_proc_t set_glUniform1i(glUniform1i_client_proc_t f) { glUniform1i_client_proc_t retval = glUniform1i; glUniform1i = f; return retval;}
-	virtual glUniform1iv_client_proc_t set_glUniform1iv(glUniform1iv_client_proc_t f) { glUniform1iv_client_proc_t retval = glUniform1iv; glUniform1iv = f; return retval;}
-	virtual glUniform2f_client_proc_t set_glUniform2f(glUniform2f_client_proc_t f) { glUniform2f_client_proc_t retval = glUniform2f; glUniform2f = f; return retval;}
-	virtual glUniform2fv_client_proc_t set_glUniform2fv(glUniform2fv_client_proc_t f) { glUniform2fv_client_proc_t retval = glUniform2fv; glUniform2fv = f; return retval;}
-	virtual glUniform2i_client_proc_t set_glUniform2i(glUniform2i_client_proc_t f) { glUniform2i_client_proc_t retval = glUniform2i; glUniform2i = f; return retval;}
-	virtual glUniform2iv_client_proc_t set_glUniform2iv(glUniform2iv_client_proc_t f) { glUniform2iv_client_proc_t retval = glUniform2iv; glUniform2iv = f; return retval;}
-	virtual glUniform3f_client_proc_t set_glUniform3f(glUniform3f_client_proc_t f) { glUniform3f_client_proc_t retval = glUniform3f; glUniform3f = f; return retval;}
-	virtual glUniform3fv_client_proc_t set_glUniform3fv(glUniform3fv_client_proc_t f) { glUniform3fv_client_proc_t retval = glUniform3fv; glUniform3fv = f; return retval;}
-	virtual glUniform3i_client_proc_t set_glUniform3i(glUniform3i_client_proc_t f) { glUniform3i_client_proc_t retval = glUniform3i; glUniform3i = f; return retval;}
-	virtual glUniform3iv_client_proc_t set_glUniform3iv(glUniform3iv_client_proc_t f) { glUniform3iv_client_proc_t retval = glUniform3iv; glUniform3iv = f; return retval;}
-	virtual glUniform4f_client_proc_t set_glUniform4f(glUniform4f_client_proc_t f) { glUniform4f_client_proc_t retval = glUniform4f; glUniform4f = f; return retval;}
-	virtual glUniform4fv_client_proc_t set_glUniform4fv(glUniform4fv_client_proc_t f) { glUniform4fv_client_proc_t retval = glUniform4fv; glUniform4fv = f; return retval;}
-	virtual glUniform4i_client_proc_t set_glUniform4i(glUniform4i_client_proc_t f) { glUniform4i_client_proc_t retval = glUniform4i; glUniform4i = f; return retval;}
-	virtual glUniform4iv_client_proc_t set_glUniform4iv(glUniform4iv_client_proc_t f) { glUniform4iv_client_proc_t retval = glUniform4iv; glUniform4iv = f; return retval;}
-	virtual glUniformMatrix2fv_client_proc_t set_glUniformMatrix2fv(glUniformMatrix2fv_client_proc_t f) { glUniformMatrix2fv_client_proc_t retval = glUniformMatrix2fv; glUniformMatrix2fv = f; return retval;}
-	virtual glUniformMatrix3fv_client_proc_t set_glUniformMatrix3fv(glUniformMatrix3fv_client_proc_t f) { glUniformMatrix3fv_client_proc_t retval = glUniformMatrix3fv; glUniformMatrix3fv = f; return retval;}
-	virtual glUniformMatrix4fv_client_proc_t set_glUniformMatrix4fv(glUniformMatrix4fv_client_proc_t f) { glUniformMatrix4fv_client_proc_t retval = glUniformMatrix4fv; glUniformMatrix4fv = f; return retval;}
-	virtual glUseProgram_client_proc_t set_glUseProgram(glUseProgram_client_proc_t f) { glUseProgram_client_proc_t retval = glUseProgram; glUseProgram = f; return retval;}
-	virtual glValidateProgram_client_proc_t set_glValidateProgram(glValidateProgram_client_proc_t f) { glValidateProgram_client_proc_t retval = glValidateProgram; glValidateProgram = f; return retval;}
-	virtual glVertexAttrib1f_client_proc_t set_glVertexAttrib1f(glVertexAttrib1f_client_proc_t f) { glVertexAttrib1f_client_proc_t retval = glVertexAttrib1f; glVertexAttrib1f = f; return retval;}
-	virtual glVertexAttrib1fv_client_proc_t set_glVertexAttrib1fv(glVertexAttrib1fv_client_proc_t f) { glVertexAttrib1fv_client_proc_t retval = glVertexAttrib1fv; glVertexAttrib1fv = f; return retval;}
-	virtual glVertexAttrib2f_client_proc_t set_glVertexAttrib2f(glVertexAttrib2f_client_proc_t f) { glVertexAttrib2f_client_proc_t retval = glVertexAttrib2f; glVertexAttrib2f = f; return retval;}
-	virtual glVertexAttrib2fv_client_proc_t set_glVertexAttrib2fv(glVertexAttrib2fv_client_proc_t f) { glVertexAttrib2fv_client_proc_t retval = glVertexAttrib2fv; glVertexAttrib2fv = f; return retval;}
-	virtual glVertexAttrib3f_client_proc_t set_glVertexAttrib3f(glVertexAttrib3f_client_proc_t f) { glVertexAttrib3f_client_proc_t retval = glVertexAttrib3f; glVertexAttrib3f = f; return retval;}
-	virtual glVertexAttrib3fv_client_proc_t set_glVertexAttrib3fv(glVertexAttrib3fv_client_proc_t f) { glVertexAttrib3fv_client_proc_t retval = glVertexAttrib3fv; glVertexAttrib3fv = f; return retval;}
-	virtual glVertexAttrib4f_client_proc_t set_glVertexAttrib4f(glVertexAttrib4f_client_proc_t f) { glVertexAttrib4f_client_proc_t retval = glVertexAttrib4f; glVertexAttrib4f = f; return retval;}
-	virtual glVertexAttrib4fv_client_proc_t set_glVertexAttrib4fv(glVertexAttrib4fv_client_proc_t f) { glVertexAttrib4fv_client_proc_t retval = glVertexAttrib4fv; glVertexAttrib4fv = f; return retval;}
-	virtual glVertexAttribPointer_client_proc_t set_glVertexAttribPointer(glVertexAttribPointer_client_proc_t f) { glVertexAttribPointer_client_proc_t retval = glVertexAttribPointer; glVertexAttribPointer = f; return retval;}
-	virtual glViewport_client_proc_t set_glViewport(glViewport_client_proc_t f) { glViewport_client_proc_t retval = glViewport; glViewport = f; return retval;}
-	virtual glEGLImageTargetTexture2DOES_client_proc_t set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES_client_proc_t f) { glEGLImageTargetTexture2DOES_client_proc_t retval = glEGLImageTargetTexture2DOES; glEGLImageTargetTexture2DOES = f; return retval;}
-	virtual glEGLImageTargetRenderbufferStorageOES_client_proc_t set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES_client_proc_t f) { glEGLImageTargetRenderbufferStorageOES_client_proc_t retval = glEGLImageTargetRenderbufferStorageOES; glEGLImageTargetRenderbufferStorageOES = f; return retval;}
-	virtual glGetProgramBinaryOES_client_proc_t set_glGetProgramBinaryOES(glGetProgramBinaryOES_client_proc_t f) { glGetProgramBinaryOES_client_proc_t retval = glGetProgramBinaryOES; glGetProgramBinaryOES = f; return retval;}
-	virtual glProgramBinaryOES_client_proc_t set_glProgramBinaryOES(glProgramBinaryOES_client_proc_t f) { glProgramBinaryOES_client_proc_t retval = glProgramBinaryOES; glProgramBinaryOES = f; return retval;}
-	virtual glMapBufferOES_client_proc_t set_glMapBufferOES(glMapBufferOES_client_proc_t f) { glMapBufferOES_client_proc_t retval = glMapBufferOES; glMapBufferOES = f; return retval;}
-	virtual glUnmapBufferOES_client_proc_t set_glUnmapBufferOES(glUnmapBufferOES_client_proc_t f) { glUnmapBufferOES_client_proc_t retval = glUnmapBufferOES; glUnmapBufferOES = f; return retval;}
-	virtual glTexImage3DOES_client_proc_t set_glTexImage3DOES(glTexImage3DOES_client_proc_t f) { glTexImage3DOES_client_proc_t retval = glTexImage3DOES; glTexImage3DOES = f; return retval;}
-	virtual glTexSubImage3DOES_client_proc_t set_glTexSubImage3DOES(glTexSubImage3DOES_client_proc_t f) { glTexSubImage3DOES_client_proc_t retval = glTexSubImage3DOES; glTexSubImage3DOES = f; return retval;}
-	virtual glCopyTexSubImage3DOES_client_proc_t set_glCopyTexSubImage3DOES(glCopyTexSubImage3DOES_client_proc_t f) { glCopyTexSubImage3DOES_client_proc_t retval = glCopyTexSubImage3DOES; glCopyTexSubImage3DOES = f; return retval;}
-	virtual glCompressedTexImage3DOES_client_proc_t set_glCompressedTexImage3DOES(glCompressedTexImage3DOES_client_proc_t f) { glCompressedTexImage3DOES_client_proc_t retval = glCompressedTexImage3DOES; glCompressedTexImage3DOES = f; return retval;}
-	virtual glCompressedTexSubImage3DOES_client_proc_t set_glCompressedTexSubImage3DOES(glCompressedTexSubImage3DOES_client_proc_t f) { glCompressedTexSubImage3DOES_client_proc_t retval = glCompressedTexSubImage3DOES; glCompressedTexSubImage3DOES = f; return retval;}
-	virtual glFramebufferTexture3DOES_client_proc_t set_glFramebufferTexture3DOES(glFramebufferTexture3DOES_client_proc_t f) { glFramebufferTexture3DOES_client_proc_t retval = glFramebufferTexture3DOES; glFramebufferTexture3DOES = f; return retval;}
-	virtual glBindVertexArrayOES_client_proc_t set_glBindVertexArrayOES(glBindVertexArrayOES_client_proc_t f) { glBindVertexArrayOES_client_proc_t retval = glBindVertexArrayOES; glBindVertexArrayOES = f; return retval;}
-	virtual glDeleteVertexArraysOES_client_proc_t set_glDeleteVertexArraysOES(glDeleteVertexArraysOES_client_proc_t f) { glDeleteVertexArraysOES_client_proc_t retval = glDeleteVertexArraysOES; glDeleteVertexArraysOES = f; return retval;}
-	virtual glGenVertexArraysOES_client_proc_t set_glGenVertexArraysOES(glGenVertexArraysOES_client_proc_t f) { glGenVertexArraysOES_client_proc_t retval = glGenVertexArraysOES; glGenVertexArraysOES = f; return retval;}
-	virtual glIsVertexArrayOES_client_proc_t set_glIsVertexArrayOES(glIsVertexArrayOES_client_proc_t f) { glIsVertexArrayOES_client_proc_t retval = glIsVertexArrayOES; glIsVertexArrayOES = f; return retval;}
-	virtual glDiscardFramebufferEXT_client_proc_t set_glDiscardFramebufferEXT(glDiscardFramebufferEXT_client_proc_t f) { glDiscardFramebufferEXT_client_proc_t retval = glDiscardFramebufferEXT; glDiscardFramebufferEXT = f; return retval;}
-	virtual glMultiDrawArraysEXT_client_proc_t set_glMultiDrawArraysEXT(glMultiDrawArraysEXT_client_proc_t f) { glMultiDrawArraysEXT_client_proc_t retval = glMultiDrawArraysEXT; glMultiDrawArraysEXT = f; return retval;}
-	virtual glMultiDrawElementsEXT_client_proc_t set_glMultiDrawElementsEXT(glMultiDrawElementsEXT_client_proc_t f) { glMultiDrawElementsEXT_client_proc_t retval = glMultiDrawElementsEXT; glMultiDrawElementsEXT = f; return retval;}
-	virtual glGetPerfMonitorGroupsAMD_client_proc_t set_glGetPerfMonitorGroupsAMD(glGetPerfMonitorGroupsAMD_client_proc_t f) { glGetPerfMonitorGroupsAMD_client_proc_t retval = glGetPerfMonitorGroupsAMD; glGetPerfMonitorGroupsAMD = f; return retval;}
-	virtual glGetPerfMonitorCountersAMD_client_proc_t set_glGetPerfMonitorCountersAMD(glGetPerfMonitorCountersAMD_client_proc_t f) { glGetPerfMonitorCountersAMD_client_proc_t retval = glGetPerfMonitorCountersAMD; glGetPerfMonitorCountersAMD = f; return retval;}
-	virtual glGetPerfMonitorGroupStringAMD_client_proc_t set_glGetPerfMonitorGroupStringAMD(glGetPerfMonitorGroupStringAMD_client_proc_t f) { glGetPerfMonitorGroupStringAMD_client_proc_t retval = glGetPerfMonitorGroupStringAMD; glGetPerfMonitorGroupStringAMD = f; return retval;}
-	virtual glGetPerfMonitorCounterStringAMD_client_proc_t set_glGetPerfMonitorCounterStringAMD(glGetPerfMonitorCounterStringAMD_client_proc_t f) { glGetPerfMonitorCounterStringAMD_client_proc_t retval = glGetPerfMonitorCounterStringAMD; glGetPerfMonitorCounterStringAMD = f; return retval;}
-	virtual glGetPerfMonitorCounterInfoAMD_client_proc_t set_glGetPerfMonitorCounterInfoAMD(glGetPerfMonitorCounterInfoAMD_client_proc_t f) { glGetPerfMonitorCounterInfoAMD_client_proc_t retval = glGetPerfMonitorCounterInfoAMD; glGetPerfMonitorCounterInfoAMD = f; return retval;}
-	virtual glGenPerfMonitorsAMD_client_proc_t set_glGenPerfMonitorsAMD(glGenPerfMonitorsAMD_client_proc_t f) { glGenPerfMonitorsAMD_client_proc_t retval = glGenPerfMonitorsAMD; glGenPerfMonitorsAMD = f; return retval;}
-	virtual glDeletePerfMonitorsAMD_client_proc_t set_glDeletePerfMonitorsAMD(glDeletePerfMonitorsAMD_client_proc_t f) { glDeletePerfMonitorsAMD_client_proc_t retval = glDeletePerfMonitorsAMD; glDeletePerfMonitorsAMD = f; return retval;}
-	virtual glSelectPerfMonitorCountersAMD_client_proc_t set_glSelectPerfMonitorCountersAMD(glSelectPerfMonitorCountersAMD_client_proc_t f) { glSelectPerfMonitorCountersAMD_client_proc_t retval = glSelectPerfMonitorCountersAMD; glSelectPerfMonitorCountersAMD = f; return retval;}
-	virtual glBeginPerfMonitorAMD_client_proc_t set_glBeginPerfMonitorAMD(glBeginPerfMonitorAMD_client_proc_t f) { glBeginPerfMonitorAMD_client_proc_t retval = glBeginPerfMonitorAMD; glBeginPerfMonitorAMD = f; return retval;}
-	virtual glEndPerfMonitorAMD_client_proc_t set_glEndPerfMonitorAMD(glEndPerfMonitorAMD_client_proc_t f) { glEndPerfMonitorAMD_client_proc_t retval = glEndPerfMonitorAMD; glEndPerfMonitorAMD = f; return retval;}
-	virtual glGetPerfMonitorCounterDataAMD_client_proc_t set_glGetPerfMonitorCounterDataAMD(glGetPerfMonitorCounterDataAMD_client_proc_t f) { glGetPerfMonitorCounterDataAMD_client_proc_t retval = glGetPerfMonitorCounterDataAMD; glGetPerfMonitorCounterDataAMD = f; return retval;}
-	virtual glRenderbufferStorageMultisampleIMG_client_proc_t set_glRenderbufferStorageMultisampleIMG(glRenderbufferStorageMultisampleIMG_client_proc_t f) { glRenderbufferStorageMultisampleIMG_client_proc_t retval = glRenderbufferStorageMultisampleIMG; glRenderbufferStorageMultisampleIMG = f; return retval;}
-	virtual glFramebufferTexture2DMultisampleIMG_client_proc_t set_glFramebufferTexture2DMultisampleIMG(glFramebufferTexture2DMultisampleIMG_client_proc_t f) { glFramebufferTexture2DMultisampleIMG_client_proc_t retval = glFramebufferTexture2DMultisampleIMG; glFramebufferTexture2DMultisampleIMG = f; return retval;}
-	virtual glDeleteFencesNV_client_proc_t set_glDeleteFencesNV(glDeleteFencesNV_client_proc_t f) { glDeleteFencesNV_client_proc_t retval = glDeleteFencesNV; glDeleteFencesNV = f; return retval;}
-	virtual glGenFencesNV_client_proc_t set_glGenFencesNV(glGenFencesNV_client_proc_t f) { glGenFencesNV_client_proc_t retval = glGenFencesNV; glGenFencesNV = f; return retval;}
-	virtual glIsFenceNV_client_proc_t set_glIsFenceNV(glIsFenceNV_client_proc_t f) { glIsFenceNV_client_proc_t retval = glIsFenceNV; glIsFenceNV = f; return retval;}
-	virtual glTestFenceNV_client_proc_t set_glTestFenceNV(glTestFenceNV_client_proc_t f) { glTestFenceNV_client_proc_t retval = glTestFenceNV; glTestFenceNV = f; return retval;}
-	virtual glGetFenceivNV_client_proc_t set_glGetFenceivNV(glGetFenceivNV_client_proc_t f) { glGetFenceivNV_client_proc_t retval = glGetFenceivNV; glGetFenceivNV = f; return retval;}
-	virtual glFinishFenceNV_client_proc_t set_glFinishFenceNV(glFinishFenceNV_client_proc_t f) { glFinishFenceNV_client_proc_t retval = glFinishFenceNV; glFinishFenceNV = f; return retval;}
-	virtual glSetFenceNV_client_proc_t set_glSetFenceNV(glSetFenceNV_client_proc_t f) { glSetFenceNV_client_proc_t retval = glSetFenceNV; glSetFenceNV = f; return retval;}
-	virtual glCoverageMaskNV_client_proc_t set_glCoverageMaskNV(glCoverageMaskNV_client_proc_t f) { glCoverageMaskNV_client_proc_t retval = glCoverageMaskNV; glCoverageMaskNV = f; return retval;}
-	virtual glCoverageOperationNV_client_proc_t set_glCoverageOperationNV(glCoverageOperationNV_client_proc_t f) { glCoverageOperationNV_client_proc_t retval = glCoverageOperationNV; glCoverageOperationNV = f; return retval;}
-	virtual glGetDriverControlsQCOM_client_proc_t set_glGetDriverControlsQCOM(glGetDriverControlsQCOM_client_proc_t f) { glGetDriverControlsQCOM_client_proc_t retval = glGetDriverControlsQCOM; glGetDriverControlsQCOM = f; return retval;}
-	virtual glGetDriverControlStringQCOM_client_proc_t set_glGetDriverControlStringQCOM(glGetDriverControlStringQCOM_client_proc_t f) { glGetDriverControlStringQCOM_client_proc_t retval = glGetDriverControlStringQCOM; glGetDriverControlStringQCOM = f; return retval;}
-	virtual glEnableDriverControlQCOM_client_proc_t set_glEnableDriverControlQCOM(glEnableDriverControlQCOM_client_proc_t f) { glEnableDriverControlQCOM_client_proc_t retval = glEnableDriverControlQCOM; glEnableDriverControlQCOM = f; return retval;}
-	virtual glDisableDriverControlQCOM_client_proc_t set_glDisableDriverControlQCOM(glDisableDriverControlQCOM_client_proc_t f) { glDisableDriverControlQCOM_client_proc_t retval = glDisableDriverControlQCOM; glDisableDriverControlQCOM = f; return retval;}
-	virtual glExtGetTexturesQCOM_client_proc_t set_glExtGetTexturesQCOM(glExtGetTexturesQCOM_client_proc_t f) { glExtGetTexturesQCOM_client_proc_t retval = glExtGetTexturesQCOM; glExtGetTexturesQCOM = f; return retval;}
-	virtual glExtGetBuffersQCOM_client_proc_t set_glExtGetBuffersQCOM(glExtGetBuffersQCOM_client_proc_t f) { glExtGetBuffersQCOM_client_proc_t retval = glExtGetBuffersQCOM; glExtGetBuffersQCOM = f; return retval;}
-	virtual glExtGetRenderbuffersQCOM_client_proc_t set_glExtGetRenderbuffersQCOM(glExtGetRenderbuffersQCOM_client_proc_t f) { glExtGetRenderbuffersQCOM_client_proc_t retval = glExtGetRenderbuffersQCOM; glExtGetRenderbuffersQCOM = f; return retval;}
-	virtual glExtGetFramebuffersQCOM_client_proc_t set_glExtGetFramebuffersQCOM(glExtGetFramebuffersQCOM_client_proc_t f) { glExtGetFramebuffersQCOM_client_proc_t retval = glExtGetFramebuffersQCOM; glExtGetFramebuffersQCOM = f; return retval;}
-	virtual glExtGetTexLevelParameterivQCOM_client_proc_t set_glExtGetTexLevelParameterivQCOM(glExtGetTexLevelParameterivQCOM_client_proc_t f) { glExtGetTexLevelParameterivQCOM_client_proc_t retval = glExtGetTexLevelParameterivQCOM; glExtGetTexLevelParameterivQCOM = f; return retval;}
-	virtual glExtTexObjectStateOverrideiQCOM_client_proc_t set_glExtTexObjectStateOverrideiQCOM(glExtTexObjectStateOverrideiQCOM_client_proc_t f) { glExtTexObjectStateOverrideiQCOM_client_proc_t retval = glExtTexObjectStateOverrideiQCOM; glExtTexObjectStateOverrideiQCOM = f; return retval;}
-	virtual glExtGetTexSubImageQCOM_client_proc_t set_glExtGetTexSubImageQCOM(glExtGetTexSubImageQCOM_client_proc_t f) { glExtGetTexSubImageQCOM_client_proc_t retval = glExtGetTexSubImageQCOM; glExtGetTexSubImageQCOM = f; return retval;}
-	virtual glExtGetBufferPointervQCOM_client_proc_t set_glExtGetBufferPointervQCOM(glExtGetBufferPointervQCOM_client_proc_t f) { glExtGetBufferPointervQCOM_client_proc_t retval = glExtGetBufferPointervQCOM; glExtGetBufferPointervQCOM = f; return retval;}
-	virtual glExtGetShadersQCOM_client_proc_t set_glExtGetShadersQCOM(glExtGetShadersQCOM_client_proc_t f) { glExtGetShadersQCOM_client_proc_t retval = glExtGetShadersQCOM; glExtGetShadersQCOM = f; return retval;}
-	virtual glExtGetProgramsQCOM_client_proc_t set_glExtGetProgramsQCOM(glExtGetProgramsQCOM_client_proc_t f) { glExtGetProgramsQCOM_client_proc_t retval = glExtGetProgramsQCOM; glExtGetProgramsQCOM = f; return retval;}
-	virtual glExtIsProgramBinaryQCOM_client_proc_t set_glExtIsProgramBinaryQCOM(glExtIsProgramBinaryQCOM_client_proc_t f) { glExtIsProgramBinaryQCOM_client_proc_t retval = glExtIsProgramBinaryQCOM; glExtIsProgramBinaryQCOM = f; return retval;}
-	virtual glExtGetProgramBinarySourceQCOM_client_proc_t set_glExtGetProgramBinarySourceQCOM(glExtGetProgramBinarySourceQCOM_client_proc_t f) { glExtGetProgramBinarySourceQCOM_client_proc_t retval = glExtGetProgramBinarySourceQCOM; glExtGetProgramBinarySourceQCOM = f; return retval;}
-	virtual glStartTilingQCOM_client_proc_t set_glStartTilingQCOM(glStartTilingQCOM_client_proc_t f) { glStartTilingQCOM_client_proc_t retval = glStartTilingQCOM; glStartTilingQCOM = f; return retval;}
-	virtual glEndTilingQCOM_client_proc_t set_glEndTilingQCOM(glEndTilingQCOM_client_proc_t f) { glEndTilingQCOM_client_proc_t retval = glEndTilingQCOM; glEndTilingQCOM = f; return retval;}
-	virtual glVertexAttribPointerData_client_proc_t set_glVertexAttribPointerData(glVertexAttribPointerData_client_proc_t f) { glVertexAttribPointerData_client_proc_t retval = glVertexAttribPointerData; glVertexAttribPointerData = f; return retval;}
-	virtual glVertexAttribPointerOffset_client_proc_t set_glVertexAttribPointerOffset(glVertexAttribPointerOffset_client_proc_t f) { glVertexAttribPointerOffset_client_proc_t retval = glVertexAttribPointerOffset; glVertexAttribPointerOffset = f; return retval;}
-	virtual glDrawElementsOffset_client_proc_t set_glDrawElementsOffset(glDrawElementsOffset_client_proc_t f) { glDrawElementsOffset_client_proc_t retval = glDrawElementsOffset; glDrawElementsOffset = f; return retval;}
-	virtual glDrawElementsData_client_proc_t set_glDrawElementsData(glDrawElementsData_client_proc_t f) { glDrawElementsData_client_proc_t retval = glDrawElementsData; glDrawElementsData = f; return retval;}
-	virtual glGetCompressedTextureFormats_client_proc_t set_glGetCompressedTextureFormats(glGetCompressedTextureFormats_client_proc_t f) { glGetCompressedTextureFormats_client_proc_t retval = glGetCompressedTextureFormats; glGetCompressedTextureFormats = f; return retval;}
-	virtual glShaderString_client_proc_t set_glShaderString(glShaderString_client_proc_t f) { glShaderString_client_proc_t retval = glShaderString; glShaderString = f; return retval;}
-	virtual glFinishRoundTrip_client_proc_t set_glFinishRoundTrip(glFinishRoundTrip_client_proc_t f) { glFinishRoundTrip_client_proc_t retval = glFinishRoundTrip; glFinishRoundTrip = f; return retval;}
 	 virtual ~gl2_client_context_t() {}
 
 	typedef gl2_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
 	static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f);
 	int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData);
-	virtual void setError(unsigned int  error){};
+	virtual void setError(unsigned int  error){ (void)error; };
 	virtual unsigned int getError(){ return 0; };
 };
 
diff --git a/opengl/system/GLESv2_enc/gl2_client_proc.h b/opengl/system/GLESv2_enc/gl2_client_proc.h
index 1a9f696..445910d 100644
--- a/opengl/system/GLESv2_enc/gl2_client_proc.h
+++ b/opengl/system/GLESv2_enc/gl2_client_proc.h
@@ -7,7 +7,7 @@
 
 #include "gl2_types.h"
 #ifndef gl2_APIENTRY
-#define gl2_APIENTRY
+#define gl2_APIENTRY 
 #endif
 typedef void (gl2_APIENTRY *glActiveTexture_client_proc_t) (void * ctx, GLenum);
 typedef void (gl2_APIENTRY *glAttachShader_client_proc_t) (void * ctx, GLuint, GLuint);
diff --git a/opengl/system/GLESv2_enc/gl2_enc.cpp b/opengl/system/GLESv2_enc/gl2_enc.cpp
index 5929697..1c4f73c 100644
--- a/opengl/system/GLESv2_enc/gl2_enc.cpp
+++ b/opengl/system/GLESv2_enc/gl2_enc.cpp
@@ -9,7 +9,10 @@
 
 
 #include <stdio.h>
-static void enc_unsupported()
+
+namespace {
+
+void enc_unsupported()
 {
 	ALOGE("Function is unsupported\n");
 }
@@ -471,7 +474,7 @@ GLuint glCreateProgram_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glCreateProgram;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -764,7 +767,7 @@ void glFinish_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glFinish;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -778,7 +781,7 @@ void glFlush_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glFlush;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1070,7 +1073,7 @@ GLenum glGetError_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glGetError;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1162,7 +1165,7 @@ void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsiz
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_length = ((length != NULL) ?  (sizeof(GLsizei)) : 0);
+	const unsigned int __size_length = ((length != NULL) ?  sizeof(GLsizei) : 0);
 	const unsigned int __size_infolog =  bufsize;
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + __size_length + __size_infolog + 2*4;
@@ -1326,7 +1329,7 @@ void glGetUniformfv_enc(void *self , GLuint program, GLint location, GLfloat* pa
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_params =  glSizeof(uniformType(self, program, location));
+	const unsigned int __size_params =  glSizeof(glesv2_enc::uniformType(self, program, location));
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + __size_params + 1*4;
 	ptr = stream->alloc(packetSize);
@@ -1345,7 +1348,7 @@ void glGetUniformiv_enc(void *self , GLuint program, GLint location, GLint* para
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_params =  glSizeof(uniformType(self, program, location));
+	const unsigned int __size_params =  glSizeof(glesv2_enc::uniformType(self, program, location));
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + __size_params + 1*4;
 	ptr = stream->alloc(packetSize);
@@ -1635,7 +1638,7 @@ void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei heig
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels =  pixelDataSize(self, width, height, format, type, 1);
+	const unsigned int __size_pixels =  glesv2_enc::pixelDataSize(self, width, height, format, type, 1);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(packetSize);
@@ -1659,7 +1662,7 @@ void glReleaseShaderCompiler_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glReleaseShaderCompiler;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -1825,7 +1828,7 @@ void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalfor
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels = ((pixels != NULL) ?  pixelDataSize(self, width, height, format, type, 0) : 0);
+	const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -1923,7 +1926,7 @@ void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset,
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels = ((pixels != NULL) ?  pixelDataSize(self, width, height, format, type, 0) : 0);
+	const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize(self, width, height, format, type, 0) : 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -2542,7 +2545,7 @@ void glTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum interna
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels = ((pixels != NULL) ?  pixelDataSize3D(self, width, height, depth, format, type, 0) : 0);
+	const unsigned int __size_pixels = ((pixels != NULL) ?  glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0) : 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -2569,7 +2572,7 @@ void glTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffs
 	gl2_encoder_context_t *ctx = (gl2_encoder_context_t *)self;
 	IOStream *stream = ctx->m_stream;
 
-	const unsigned int __size_pixels =  pixelDataSize3D(self, width, height, depth, format, type, 0);
+	const unsigned int __size_pixels =  glesv2_enc::pixelDataSize3D(self, width, height, depth, format, type, 0);
 	 unsigned char *ptr;
 	 const size_t packetSize = 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + __size_pixels + 1*4;
 	ptr = stream->alloc(8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
@@ -2903,7 +2906,7 @@ int glFinishRoundTrip_enc(void *self )
 	IOStream *stream = ctx->m_stream;
 
 	 unsigned char *ptr;
-	 const size_t packetSize = 8 + 0;
+	 const size_t packetSize = 8;
 	ptr = stream->alloc(packetSize);
 	int tmp = OP_glFinishRoundTrip;memcpy(ptr, &tmp, 4); ptr += 4;
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
@@ -2914,217 +2917,219 @@ int glFinishRoundTrip_enc(void *self )
 	return retval;
 }
 
+}  // namespace
+
 gl2_encoder_context_t::gl2_encoder_context_t(IOStream *stream)
 {
 	m_stream = stream;
 
-	set_glActiveTexture(glActiveTexture_enc);
-	set_glAttachShader(glAttachShader_enc);
-	set_glBindAttribLocation(glBindAttribLocation_enc);
-	set_glBindBuffer(glBindBuffer_enc);
-	set_glBindFramebuffer(glBindFramebuffer_enc);
-	set_glBindRenderbuffer(glBindRenderbuffer_enc);
-	set_glBindTexture(glBindTexture_enc);
-	set_glBlendColor(glBlendColor_enc);
-	set_glBlendEquation(glBlendEquation_enc);
-	set_glBlendEquationSeparate(glBlendEquationSeparate_enc);
-	set_glBlendFunc(glBlendFunc_enc);
-	set_glBlendFuncSeparate(glBlendFuncSeparate_enc);
-	set_glBufferData(glBufferData_enc);
-	set_glBufferSubData(glBufferSubData_enc);
-	set_glCheckFramebufferStatus(glCheckFramebufferStatus_enc);
-	set_glClear(glClear_enc);
-	set_glClearColor(glClearColor_enc);
-	set_glClearDepthf(glClearDepthf_enc);
-	set_glClearStencil(glClearStencil_enc);
-	set_glColorMask(glColorMask_enc);
-	set_glCompileShader(glCompileShader_enc);
-	set_glCompressedTexImage2D(glCompressedTexImage2D_enc);
-	set_glCompressedTexSubImage2D(glCompressedTexSubImage2D_enc);
-	set_glCopyTexImage2D(glCopyTexImage2D_enc);
-	set_glCopyTexSubImage2D(glCopyTexSubImage2D_enc);
-	set_glCreateProgram(glCreateProgram_enc);
-	set_glCreateShader(glCreateShader_enc);
-	set_glCullFace(glCullFace_enc);
-	set_glDeleteBuffers(glDeleteBuffers_enc);
-	set_glDeleteFramebuffers(glDeleteFramebuffers_enc);
-	set_glDeleteProgram(glDeleteProgram_enc);
-	set_glDeleteRenderbuffers(glDeleteRenderbuffers_enc);
-	set_glDeleteShader(glDeleteShader_enc);
-	set_glDeleteTextures(glDeleteTextures_enc);
-	set_glDepthFunc(glDepthFunc_enc);
-	set_glDepthMask(glDepthMask_enc);
-	set_glDepthRangef(glDepthRangef_enc);
-	set_glDetachShader(glDetachShader_enc);
-	set_glDisable(glDisable_enc);
-	set_glDisableVertexAttribArray(glDisableVertexAttribArray_enc);
-	set_glDrawArrays(glDrawArrays_enc);
-	set_glDrawElements((glDrawElements_client_proc_t)(enc_unsupported));
-	set_glEnable(glEnable_enc);
-	set_glEnableVertexAttribArray(glEnableVertexAttribArray_enc);
-	set_glFinish(glFinish_enc);
-	set_glFlush(glFlush_enc);
-	set_glFramebufferRenderbuffer(glFramebufferRenderbuffer_enc);
-	set_glFramebufferTexture2D(glFramebufferTexture2D_enc);
-	set_glFrontFace(glFrontFace_enc);
-	set_glGenBuffers(glGenBuffers_enc);
-	set_glGenerateMipmap(glGenerateMipmap_enc);
-	set_glGenFramebuffers(glGenFramebuffers_enc);
-	set_glGenRenderbuffers(glGenRenderbuffers_enc);
-	set_glGenTextures(glGenTextures_enc);
-	set_glGetActiveAttrib(glGetActiveAttrib_enc);
-	set_glGetActiveUniform(glGetActiveUniform_enc);
-	set_glGetAttachedShaders(glGetAttachedShaders_enc);
-	set_glGetAttribLocation(glGetAttribLocation_enc);
-	set_glGetBooleanv(glGetBooleanv_enc);
-	set_glGetBufferParameteriv(glGetBufferParameteriv_enc);
-	set_glGetError(glGetError_enc);
-	set_glGetFloatv(glGetFloatv_enc);
-	set_glGetFramebufferAttachmentParameteriv(glGetFramebufferAttachmentParameteriv_enc);
-	set_glGetIntegerv(glGetIntegerv_enc);
-	set_glGetProgramiv(glGetProgramiv_enc);
-	set_glGetProgramInfoLog(glGetProgramInfoLog_enc);
-	set_glGetRenderbufferParameteriv(glGetRenderbufferParameteriv_enc);
-	set_glGetShaderiv(glGetShaderiv_enc);
-	set_glGetShaderInfoLog(glGetShaderInfoLog_enc);
-	set_glGetShaderPrecisionFormat(glGetShaderPrecisionFormat_enc);
-	set_glGetShaderSource(glGetShaderSource_enc);
-	set_glGetString((glGetString_client_proc_t)(enc_unsupported));
-	set_glGetTexParameterfv(glGetTexParameterfv_enc);
-	set_glGetTexParameteriv(glGetTexParameteriv_enc);
-	set_glGetUniformfv(glGetUniformfv_enc);
-	set_glGetUniformiv(glGetUniformiv_enc);
-	set_glGetUniformLocation(glGetUniformLocation_enc);
-	set_glGetVertexAttribfv(glGetVertexAttribfv_enc);
-	set_glGetVertexAttribiv(glGetVertexAttribiv_enc);
-	set_glGetVertexAttribPointerv((glGetVertexAttribPointerv_client_proc_t)(enc_unsupported));
-	set_glHint(glHint_enc);
-	set_glIsBuffer(glIsBuffer_enc);
-	set_glIsEnabled(glIsEnabled_enc);
-	set_glIsFramebuffer(glIsFramebuffer_enc);
-	set_glIsProgram(glIsProgram_enc);
-	set_glIsRenderbuffer(glIsRenderbuffer_enc);
-	set_glIsShader(glIsShader_enc);
-	set_glIsTexture(glIsTexture_enc);
-	set_glLineWidth(glLineWidth_enc);
-	set_glLinkProgram(glLinkProgram_enc);
-	set_glPixelStorei(glPixelStorei_enc);
-	set_glPolygonOffset(glPolygonOffset_enc);
-	set_glReadPixels(glReadPixels_enc);
-	set_glReleaseShaderCompiler(glReleaseShaderCompiler_enc);
-	set_glRenderbufferStorage(glRenderbufferStorage_enc);
-	set_glSampleCoverage(glSampleCoverage_enc);
-	set_glScissor(glScissor_enc);
-	set_glShaderBinary((glShaderBinary_client_proc_t)(enc_unsupported));
-	set_glShaderSource((glShaderSource_client_proc_t)(enc_unsupported));
-	set_glStencilFunc(glStencilFunc_enc);
-	set_glStencilFuncSeparate(glStencilFuncSeparate_enc);
-	set_glStencilMask(glStencilMask_enc);
-	set_glStencilMaskSeparate(glStencilMaskSeparate_enc);
-	set_glStencilOp(glStencilOp_enc);
-	set_glStencilOpSeparate(glStencilOpSeparate_enc);
-	set_glTexImage2D(glTexImage2D_enc);
-	set_glTexParameterf(glTexParameterf_enc);
-	set_glTexParameterfv(glTexParameterfv_enc);
-	set_glTexParameteri(glTexParameteri_enc);
-	set_glTexParameteriv(glTexParameteriv_enc);
-	set_glTexSubImage2D(glTexSubImage2D_enc);
-	set_glUniform1f(glUniform1f_enc);
-	set_glUniform1fv(glUniform1fv_enc);
-	set_glUniform1i(glUniform1i_enc);
-	set_glUniform1iv(glUniform1iv_enc);
-	set_glUniform2f(glUniform2f_enc);
-	set_glUniform2fv(glUniform2fv_enc);
-	set_glUniform2i(glUniform2i_enc);
-	set_glUniform2iv(glUniform2iv_enc);
-	set_glUniform3f(glUniform3f_enc);
-	set_glUniform3fv(glUniform3fv_enc);
-	set_glUniform3i(glUniform3i_enc);
-	set_glUniform3iv(glUniform3iv_enc);
-	set_glUniform4f(glUniform4f_enc);
-	set_glUniform4fv(glUniform4fv_enc);
-	set_glUniform4i(glUniform4i_enc);
-	set_glUniform4iv(glUniform4iv_enc);
-	set_glUniformMatrix2fv(glUniformMatrix2fv_enc);
-	set_glUniformMatrix3fv(glUniformMatrix3fv_enc);
-	set_glUniformMatrix4fv(glUniformMatrix4fv_enc);
-	set_glUseProgram(glUseProgram_enc);
-	set_glValidateProgram(glValidateProgram_enc);
-	set_glVertexAttrib1f(glVertexAttrib1f_enc);
-	set_glVertexAttrib1fv(glVertexAttrib1fv_enc);
-	set_glVertexAttrib2f(glVertexAttrib2f_enc);
-	set_glVertexAttrib2fv(glVertexAttrib2fv_enc);
-	set_glVertexAttrib3f(glVertexAttrib3f_enc);
-	set_glVertexAttrib3fv(glVertexAttrib3fv_enc);
-	set_glVertexAttrib4f(glVertexAttrib4f_enc);
-	set_glVertexAttrib4fv(glVertexAttrib4fv_enc);
-	set_glVertexAttribPointer((glVertexAttribPointer_client_proc_t)(enc_unsupported));
-	set_glViewport(glViewport_enc);
-	set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES_enc);
-	set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES_enc);
-	set_glGetProgramBinaryOES((glGetProgramBinaryOES_client_proc_t)(enc_unsupported));
-	set_glProgramBinaryOES((glProgramBinaryOES_client_proc_t)(enc_unsupported));
-	set_glMapBufferOES((glMapBufferOES_client_proc_t)(enc_unsupported));
-	set_glUnmapBufferOES(glUnmapBufferOES_enc);
-	set_glTexImage3DOES(glTexImage3DOES_enc);
-	set_glTexSubImage3DOES(glTexSubImage3DOES_enc);
-	set_glCopyTexSubImage3DOES(glCopyTexSubImage3DOES_enc);
-	set_glCompressedTexImage3DOES(glCompressedTexImage3DOES_enc);
-	set_glCompressedTexSubImage3DOES(glCompressedTexSubImage3DOES_enc);
-	set_glFramebufferTexture3DOES(glFramebufferTexture3DOES_enc);
-	set_glBindVertexArrayOES(glBindVertexArrayOES_enc);
-	set_glDeleteVertexArraysOES(glDeleteVertexArraysOES_enc);
-	set_glGenVertexArraysOES(glGenVertexArraysOES_enc);
-	set_glIsVertexArrayOES(glIsVertexArrayOES_enc);
-	set_glDiscardFramebufferEXT(glDiscardFramebufferEXT_enc);
-	set_glMultiDrawArraysEXT((glMultiDrawArraysEXT_client_proc_t)(enc_unsupported));
-	set_glMultiDrawElementsEXT((glMultiDrawElementsEXT_client_proc_t)(enc_unsupported));
-	set_glGetPerfMonitorGroupsAMD((glGetPerfMonitorGroupsAMD_client_proc_t)(enc_unsupported));
-	set_glGetPerfMonitorCountersAMD((glGetPerfMonitorCountersAMD_client_proc_t)(enc_unsupported));
-	set_glGetPerfMonitorGroupStringAMD((glGetPerfMonitorGroupStringAMD_client_proc_t)(enc_unsupported));
-	set_glGetPerfMonitorCounterStringAMD((glGetPerfMonitorCounterStringAMD_client_proc_t)(enc_unsupported));
-	set_glGetPerfMonitorCounterInfoAMD((glGetPerfMonitorCounterInfoAMD_client_proc_t)(enc_unsupported));
-	set_glGenPerfMonitorsAMD((glGenPerfMonitorsAMD_client_proc_t)(enc_unsupported));
-	set_glDeletePerfMonitorsAMD((glDeletePerfMonitorsAMD_client_proc_t)(enc_unsupported));
-	set_glSelectPerfMonitorCountersAMD((glSelectPerfMonitorCountersAMD_client_proc_t)(enc_unsupported));
-	set_glBeginPerfMonitorAMD((glBeginPerfMonitorAMD_client_proc_t)(enc_unsupported));
-	set_glEndPerfMonitorAMD((glEndPerfMonitorAMD_client_proc_t)(enc_unsupported));
-	set_glGetPerfMonitorCounterDataAMD((glGetPerfMonitorCounterDataAMD_client_proc_t)(enc_unsupported));
-	set_glRenderbufferStorageMultisampleIMG((glRenderbufferStorageMultisampleIMG_client_proc_t)(enc_unsupported));
-	set_glFramebufferTexture2DMultisampleIMG((glFramebufferTexture2DMultisampleIMG_client_proc_t)(enc_unsupported));
-	set_glDeleteFencesNV((glDeleteFencesNV_client_proc_t)(enc_unsupported));
-	set_glGenFencesNV((glGenFencesNV_client_proc_t)(enc_unsupported));
-	set_glIsFenceNV((glIsFenceNV_client_proc_t)(enc_unsupported));
-	set_glTestFenceNV((glTestFenceNV_client_proc_t)(enc_unsupported));
-	set_glGetFenceivNV((glGetFenceivNV_client_proc_t)(enc_unsupported));
-	set_glFinishFenceNV((glFinishFenceNV_client_proc_t)(enc_unsupported));
-	set_glSetFenceNV((glSetFenceNV_client_proc_t)(enc_unsupported));
-	set_glCoverageMaskNV((glCoverageMaskNV_client_proc_t)(enc_unsupported));
-	set_glCoverageOperationNV((glCoverageOperationNV_client_proc_t)(enc_unsupported));
-	set_glGetDriverControlsQCOM((glGetDriverControlsQCOM_client_proc_t)(enc_unsupported));
-	set_glGetDriverControlStringQCOM((glGetDriverControlStringQCOM_client_proc_t)(enc_unsupported));
-	set_glEnableDriverControlQCOM((glEnableDriverControlQCOM_client_proc_t)(enc_unsupported));
-	set_glDisableDriverControlQCOM((glDisableDriverControlQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetTexturesQCOM((glExtGetTexturesQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetBuffersQCOM((glExtGetBuffersQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetRenderbuffersQCOM((glExtGetRenderbuffersQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetFramebuffersQCOM((glExtGetFramebuffersQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetTexLevelParameterivQCOM((glExtGetTexLevelParameterivQCOM_client_proc_t)(enc_unsupported));
-	set_glExtTexObjectStateOverrideiQCOM((glExtTexObjectStateOverrideiQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetTexSubImageQCOM((glExtGetTexSubImageQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetBufferPointervQCOM((glExtGetBufferPointervQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetShadersQCOM((glExtGetShadersQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetProgramsQCOM((glExtGetProgramsQCOM_client_proc_t)(enc_unsupported));
-	set_glExtIsProgramBinaryQCOM((glExtIsProgramBinaryQCOM_client_proc_t)(enc_unsupported));
-	set_glExtGetProgramBinarySourceQCOM((glExtGetProgramBinarySourceQCOM_client_proc_t)(enc_unsupported));
-	set_glStartTilingQCOM((glStartTilingQCOM_client_proc_t)(enc_unsupported));
-	set_glEndTilingQCOM((glEndTilingQCOM_client_proc_t)(enc_unsupported));
-	set_glVertexAttribPointerData(glVertexAttribPointerData_enc);
-	set_glVertexAttribPointerOffset(glVertexAttribPointerOffset_enc);
-	set_glDrawElementsOffset(glDrawElementsOffset_enc);
-	set_glDrawElementsData(glDrawElementsData_enc);
-	set_glGetCompressedTextureFormats(glGetCompressedTextureFormats_enc);
-	set_glShaderString(glShaderString_enc);
-	set_glFinishRoundTrip(glFinishRoundTrip_enc);
+	this->glActiveTexture = &glActiveTexture_enc;
+	this->glAttachShader = &glAttachShader_enc;
+	this->glBindAttribLocation = &glBindAttribLocation_enc;
+	this->glBindBuffer = &glBindBuffer_enc;
+	this->glBindFramebuffer = &glBindFramebuffer_enc;
+	this->glBindRenderbuffer = &glBindRenderbuffer_enc;
+	this->glBindTexture = &glBindTexture_enc;
+	this->glBlendColor = &glBlendColor_enc;
+	this->glBlendEquation = &glBlendEquation_enc;
+	this->glBlendEquationSeparate = &glBlendEquationSeparate_enc;
+	this->glBlendFunc = &glBlendFunc_enc;
+	this->glBlendFuncSeparate = &glBlendFuncSeparate_enc;
+	this->glBufferData = &glBufferData_enc;
+	this->glBufferSubData = &glBufferSubData_enc;
+	this->glCheckFramebufferStatus = &glCheckFramebufferStatus_enc;
+	this->glClear = &glClear_enc;
+	this->glClearColor = &glClearColor_enc;
+	this->glClearDepthf = &glClearDepthf_enc;
+	this->glClearStencil = &glClearStencil_enc;
+	this->glColorMask = &glColorMask_enc;
+	this->glCompileShader = &glCompileShader_enc;
+	this->glCompressedTexImage2D = &glCompressedTexImage2D_enc;
+	this->glCompressedTexSubImage2D = &glCompressedTexSubImage2D_enc;
+	this->glCopyTexImage2D = &glCopyTexImage2D_enc;
+	this->glCopyTexSubImage2D = &glCopyTexSubImage2D_enc;
+	this->glCreateProgram = &glCreateProgram_enc;
+	this->glCreateShader = &glCreateShader_enc;
+	this->glCullFace = &glCullFace_enc;
+	this->glDeleteBuffers = &glDeleteBuffers_enc;
+	this->glDeleteFramebuffers = &glDeleteFramebuffers_enc;
+	this->glDeleteProgram = &glDeleteProgram_enc;
+	this->glDeleteRenderbuffers = &glDeleteRenderbuffers_enc;
+	this->glDeleteShader = &glDeleteShader_enc;
+	this->glDeleteTextures = &glDeleteTextures_enc;
+	this->glDepthFunc = &glDepthFunc_enc;
+	this->glDepthMask = &glDepthMask_enc;
+	this->glDepthRangef = &glDepthRangef_enc;
+	this->glDetachShader = &glDetachShader_enc;
+	this->glDisable = &glDisable_enc;
+	this->glDisableVertexAttribArray = &glDisableVertexAttribArray_enc;
+	this->glDrawArrays = &glDrawArrays_enc;
+	this->glDrawElements = (glDrawElements_client_proc_t) &enc_unsupported;
+	this->glEnable = &glEnable_enc;
+	this->glEnableVertexAttribArray = &glEnableVertexAttribArray_enc;
+	this->glFinish = &glFinish_enc;
+	this->glFlush = &glFlush_enc;
+	this->glFramebufferRenderbuffer = &glFramebufferRenderbuffer_enc;
+	this->glFramebufferTexture2D = &glFramebufferTexture2D_enc;
+	this->glFrontFace = &glFrontFace_enc;
+	this->glGenBuffers = &glGenBuffers_enc;
+	this->glGenerateMipmap = &glGenerateMipmap_enc;
+	this->glGenFramebuffers = &glGenFramebuffers_enc;
+	this->glGenRenderbuffers = &glGenRenderbuffers_enc;
+	this->glGenTextures = &glGenTextures_enc;
+	this->glGetActiveAttrib = &glGetActiveAttrib_enc;
+	this->glGetActiveUniform = &glGetActiveUniform_enc;
+	this->glGetAttachedShaders = &glGetAttachedShaders_enc;
+	this->glGetAttribLocation = &glGetAttribLocation_enc;
+	this->glGetBooleanv = &glGetBooleanv_enc;
+	this->glGetBufferParameteriv = &glGetBufferParameteriv_enc;
+	this->glGetError = &glGetError_enc;
+	this->glGetFloatv = &glGetFloatv_enc;
+	this->glGetFramebufferAttachmentParameteriv = &glGetFramebufferAttachmentParameteriv_enc;
+	this->glGetIntegerv = &glGetIntegerv_enc;
+	this->glGetProgramiv = &glGetProgramiv_enc;
+	this->glGetProgramInfoLog = &glGetProgramInfoLog_enc;
+	this->glGetRenderbufferParameteriv = &glGetRenderbufferParameteriv_enc;
+	this->glGetShaderiv = &glGetShaderiv_enc;
+	this->glGetShaderInfoLog = &glGetShaderInfoLog_enc;
+	this->glGetShaderPrecisionFormat = &glGetShaderPrecisionFormat_enc;
+	this->glGetShaderSource = &glGetShaderSource_enc;
+	this->glGetString = (glGetString_client_proc_t) &enc_unsupported;
+	this->glGetTexParameterfv = &glGetTexParameterfv_enc;
+	this->glGetTexParameteriv = &glGetTexParameteriv_enc;
+	this->glGetUniformfv = &glGetUniformfv_enc;
+	this->glGetUniformiv = &glGetUniformiv_enc;
+	this->glGetUniformLocation = &glGetUniformLocation_enc;
+	this->glGetVertexAttribfv = &glGetVertexAttribfv_enc;
+	this->glGetVertexAttribiv = &glGetVertexAttribiv_enc;
+	this->glGetVertexAttribPointerv = (glGetVertexAttribPointerv_client_proc_t) &enc_unsupported;
+	this->glHint = &glHint_enc;
+	this->glIsBuffer = &glIsBuffer_enc;
+	this->glIsEnabled = &glIsEnabled_enc;
+	this->glIsFramebuffer = &glIsFramebuffer_enc;
+	this->glIsProgram = &glIsProgram_enc;
+	this->glIsRenderbuffer = &glIsRenderbuffer_enc;
+	this->glIsShader = &glIsShader_enc;
+	this->glIsTexture = &glIsTexture_enc;
+	this->glLineWidth = &glLineWidth_enc;
+	this->glLinkProgram = &glLinkProgram_enc;
+	this->glPixelStorei = &glPixelStorei_enc;
+	this->glPolygonOffset = &glPolygonOffset_enc;
+	this->glReadPixels = &glReadPixels_enc;
+	this->glReleaseShaderCompiler = &glReleaseShaderCompiler_enc;
+	this->glRenderbufferStorage = &glRenderbufferStorage_enc;
+	this->glSampleCoverage = &glSampleCoverage_enc;
+	this->glScissor = &glScissor_enc;
+	this->glShaderBinary = (glShaderBinary_client_proc_t) &enc_unsupported;
+	this->glShaderSource = (glShaderSource_client_proc_t) &enc_unsupported;
+	this->glStencilFunc = &glStencilFunc_enc;
+	this->glStencilFuncSeparate = &glStencilFuncSeparate_enc;
+	this->glStencilMask = &glStencilMask_enc;
+	this->glStencilMaskSeparate = &glStencilMaskSeparate_enc;
+	this->glStencilOp = &glStencilOp_enc;
+	this->glStencilOpSeparate = &glStencilOpSeparate_enc;
+	this->glTexImage2D = &glTexImage2D_enc;
+	this->glTexParameterf = &glTexParameterf_enc;
+	this->glTexParameterfv = &glTexParameterfv_enc;
+	this->glTexParameteri = &glTexParameteri_enc;
+	this->glTexParameteriv = &glTexParameteriv_enc;
+	this->glTexSubImage2D = &glTexSubImage2D_enc;
+	this->glUniform1f = &glUniform1f_enc;
+	this->glUniform1fv = &glUniform1fv_enc;
+	this->glUniform1i = &glUniform1i_enc;
+	this->glUniform1iv = &glUniform1iv_enc;
+	this->glUniform2f = &glUniform2f_enc;
+	this->glUniform2fv = &glUniform2fv_enc;
+	this->glUniform2i = &glUniform2i_enc;
+	this->glUniform2iv = &glUniform2iv_enc;
+	this->glUniform3f = &glUniform3f_enc;
+	this->glUniform3fv = &glUniform3fv_enc;
+	this->glUniform3i = &glUniform3i_enc;
+	this->glUniform3iv = &glUniform3iv_enc;
+	this->glUniform4f = &glUniform4f_enc;
+	this->glUniform4fv = &glUniform4fv_enc;
+	this->glUniform4i = &glUniform4i_enc;
+	this->glUniform4iv = &glUniform4iv_enc;
+	this->glUniformMatrix2fv = &glUniformMatrix2fv_enc;
+	this->glUniformMatrix3fv = &glUniformMatrix3fv_enc;
+	this->glUniformMatrix4fv = &glUniformMatrix4fv_enc;
+	this->glUseProgram = &glUseProgram_enc;
+	this->glValidateProgram = &glValidateProgram_enc;
+	this->glVertexAttrib1f = &glVertexAttrib1f_enc;
+	this->glVertexAttrib1fv = &glVertexAttrib1fv_enc;
+	this->glVertexAttrib2f = &glVertexAttrib2f_enc;
+	this->glVertexAttrib2fv = &glVertexAttrib2fv_enc;
+	this->glVertexAttrib3f = &glVertexAttrib3f_enc;
+	this->glVertexAttrib3fv = &glVertexAttrib3fv_enc;
+	this->glVertexAttrib4f = &glVertexAttrib4f_enc;
+	this->glVertexAttrib4fv = &glVertexAttrib4fv_enc;
+	this->glVertexAttribPointer = (glVertexAttribPointer_client_proc_t) &enc_unsupported;
+	this->glViewport = &glViewport_enc;
+	this->glEGLImageTargetTexture2DOES = &glEGLImageTargetTexture2DOES_enc;
+	this->glEGLImageTargetRenderbufferStorageOES = &glEGLImageTargetRenderbufferStorageOES_enc;
+	this->glGetProgramBinaryOES = (glGetProgramBinaryOES_client_proc_t) &enc_unsupported;
+	this->glProgramBinaryOES = (glProgramBinaryOES_client_proc_t) &enc_unsupported;
+	this->glMapBufferOES = (glMapBufferOES_client_proc_t) &enc_unsupported;
+	this->glUnmapBufferOES = &glUnmapBufferOES_enc;
+	this->glTexImage3DOES = &glTexImage3DOES_enc;
+	this->glTexSubImage3DOES = &glTexSubImage3DOES_enc;
+	this->glCopyTexSubImage3DOES = &glCopyTexSubImage3DOES_enc;
+	this->glCompressedTexImage3DOES = &glCompressedTexImage3DOES_enc;
+	this->glCompressedTexSubImage3DOES = &glCompressedTexSubImage3DOES_enc;
+	this->glFramebufferTexture3DOES = &glFramebufferTexture3DOES_enc;
+	this->glBindVertexArrayOES = &glBindVertexArrayOES_enc;
+	this->glDeleteVertexArraysOES = &glDeleteVertexArraysOES_enc;
+	this->glGenVertexArraysOES = &glGenVertexArraysOES_enc;
+	this->glIsVertexArrayOES = &glIsVertexArrayOES_enc;
+	this->glDiscardFramebufferEXT = &glDiscardFramebufferEXT_enc;
+	this->glMultiDrawArraysEXT = (glMultiDrawArraysEXT_client_proc_t) &enc_unsupported;
+	this->glMultiDrawElementsEXT = (glMultiDrawElementsEXT_client_proc_t) &enc_unsupported;
+	this->glGetPerfMonitorGroupsAMD = (glGetPerfMonitorGroupsAMD_client_proc_t) &enc_unsupported;
+	this->glGetPerfMonitorCountersAMD = (glGetPerfMonitorCountersAMD_client_proc_t) &enc_unsupported;
+	this->glGetPerfMonitorGroupStringAMD = (glGetPerfMonitorGroupStringAMD_client_proc_t) &enc_unsupported;
+	this->glGetPerfMonitorCounterStringAMD = (glGetPerfMonitorCounterStringAMD_client_proc_t) &enc_unsupported;
+	this->glGetPerfMonitorCounterInfoAMD = (glGetPerfMonitorCounterInfoAMD_client_proc_t) &enc_unsupported;
+	this->glGenPerfMonitorsAMD = (glGenPerfMonitorsAMD_client_proc_t) &enc_unsupported;
+	this->glDeletePerfMonitorsAMD = (glDeletePerfMonitorsAMD_client_proc_t) &enc_unsupported;
+	this->glSelectPerfMonitorCountersAMD = (glSelectPerfMonitorCountersAMD_client_proc_t) &enc_unsupported;
+	this->glBeginPerfMonitorAMD = (glBeginPerfMonitorAMD_client_proc_t) &enc_unsupported;
+	this->glEndPerfMonitorAMD = (glEndPerfMonitorAMD_client_proc_t) &enc_unsupported;
+	this->glGetPerfMonitorCounterDataAMD = (glGetPerfMonitorCounterDataAMD_client_proc_t) &enc_unsupported;
+	this->glRenderbufferStorageMultisampleIMG = (glRenderbufferStorageMultisampleIMG_client_proc_t) &enc_unsupported;
+	this->glFramebufferTexture2DMultisampleIMG = (glFramebufferTexture2DMultisampleIMG_client_proc_t) &enc_unsupported;
+	this->glDeleteFencesNV = (glDeleteFencesNV_client_proc_t) &enc_unsupported;
+	this->glGenFencesNV = (glGenFencesNV_client_proc_t) &enc_unsupported;
+	this->glIsFenceNV = (glIsFenceNV_client_proc_t) &enc_unsupported;
+	this->glTestFenceNV = (glTestFenceNV_client_proc_t) &enc_unsupported;
+	this->glGetFenceivNV = (glGetFenceivNV_client_proc_t) &enc_unsupported;
+	this->glFinishFenceNV = (glFinishFenceNV_client_proc_t) &enc_unsupported;
+	this->glSetFenceNV = (glSetFenceNV_client_proc_t) &enc_unsupported;
+	this->glCoverageMaskNV = (glCoverageMaskNV_client_proc_t) &enc_unsupported;
+	this->glCoverageOperationNV = (glCoverageOperationNV_client_proc_t) &enc_unsupported;
+	this->glGetDriverControlsQCOM = (glGetDriverControlsQCOM_client_proc_t) &enc_unsupported;
+	this->glGetDriverControlStringQCOM = (glGetDriverControlStringQCOM_client_proc_t) &enc_unsupported;
+	this->glEnableDriverControlQCOM = (glEnableDriverControlQCOM_client_proc_t) &enc_unsupported;
+	this->glDisableDriverControlQCOM = (glDisableDriverControlQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetTexturesQCOM = (glExtGetTexturesQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetBuffersQCOM = (glExtGetBuffersQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetRenderbuffersQCOM = (glExtGetRenderbuffersQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetFramebuffersQCOM = (glExtGetFramebuffersQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetTexLevelParameterivQCOM = (glExtGetTexLevelParameterivQCOM_client_proc_t) &enc_unsupported;
+	this->glExtTexObjectStateOverrideiQCOM = (glExtTexObjectStateOverrideiQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetTexSubImageQCOM = (glExtGetTexSubImageQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetBufferPointervQCOM = (glExtGetBufferPointervQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetShadersQCOM = (glExtGetShadersQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetProgramsQCOM = (glExtGetProgramsQCOM_client_proc_t) &enc_unsupported;
+	this->glExtIsProgramBinaryQCOM = (glExtIsProgramBinaryQCOM_client_proc_t) &enc_unsupported;
+	this->glExtGetProgramBinarySourceQCOM = (glExtGetProgramBinarySourceQCOM_client_proc_t) &enc_unsupported;
+	this->glStartTilingQCOM = (glStartTilingQCOM_client_proc_t) &enc_unsupported;
+	this->glEndTilingQCOM = (glEndTilingQCOM_client_proc_t) &enc_unsupported;
+	this->glVertexAttribPointerData = &glVertexAttribPointerData_enc;
+	this->glVertexAttribPointerOffset = &glVertexAttribPointerOffset_enc;
+	this->glDrawElementsOffset = &glDrawElementsOffset_enc;
+	this->glDrawElementsData = &glDrawElementsData_enc;
+	this->glGetCompressedTextureFormats = &glGetCompressedTextureFormats_enc;
+	this->glShaderString = &glShaderString_enc;
+	this->glFinishRoundTrip = &glFinishRoundTrip_enc;
 }
 
diff --git a/opengl/system/GLESv2_enc/gl2_enc.h b/opengl/system/GLESv2_enc/gl2_enc.h
index f4f3f60..6f83d3e 100644
--- a/opengl/system/GLESv2_enc/gl2_enc.h
+++ b/opengl/system/GLESv2_enc/gl2_enc.h
@@ -17,218 +17,6 @@ struct gl2_encoder_context_t : public gl2_client_context_t {
 	IOStream *m_stream;
 
 	gl2_encoder_context_t(IOStream *stream);
-
-
 };
 
-extern "C" {
-	void glActiveTexture_enc(void *self , GLenum texture);
-	void glAttachShader_enc(void *self , GLuint program, GLuint shader);
-	void glBindAttribLocation_enc(void *self , GLuint program, GLuint index, const GLchar* name);
-	void glBindBuffer_enc(void *self , GLenum target, GLuint buffer);
-	void glBindFramebuffer_enc(void *self , GLenum target, GLuint framebuffer);
-	void glBindRenderbuffer_enc(void *self , GLenum target, GLuint renderbuffer);
-	void glBindTexture_enc(void *self , GLenum target, GLuint texture);
-	void glBlendColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-	void glBlendEquation_enc(void *self , GLenum mode);
-	void glBlendEquationSeparate_enc(void *self , GLenum modeRGB, GLenum modeAlpha);
-	void glBlendFunc_enc(void *self , GLenum sfactor, GLenum dfactor);
-	void glBlendFuncSeparate_enc(void *self , GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-	void glBufferData_enc(void *self , GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
-	void glBufferSubData_enc(void *self , GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
-	GLenum glCheckFramebufferStatus_enc(void *self , GLenum target);
-	void glClear_enc(void *self , GLbitfield mask);
-	void glClearColor_enc(void *self , GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-	void glClearDepthf_enc(void *self , GLclampf depth);
-	void glClearStencil_enc(void *self , GLint s);
-	void glColorMask_enc(void *self , GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-	void glCompileShader_enc(void *self , GLuint shader);
-	void glCompressedTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data);
-	void glCompressedTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data);
-	void glCopyTexImage2D_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-	void glCopyTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-	GLuint glCreateProgram_enc(void *self );
-	GLuint glCreateShader_enc(void *self , GLenum type);
-	void glCullFace_enc(void *self , GLenum mode);
-	void glDeleteBuffers_enc(void *self , GLsizei n, const GLuint* buffers);
-	void glDeleteFramebuffers_enc(void *self , GLsizei n, const GLuint* framebuffers);
-	void glDeleteProgram_enc(void *self , GLuint program);
-	void glDeleteRenderbuffers_enc(void *self , GLsizei n, const GLuint* renderbuffers);
-	void glDeleteShader_enc(void *self , GLuint shader);
-	void glDeleteTextures_enc(void *self , GLsizei n, const GLuint* textures);
-	void glDepthFunc_enc(void *self , GLenum func);
-	void glDepthMask_enc(void *self , GLboolean flag);
-	void glDepthRangef_enc(void *self , GLclampf zNear, GLclampf zFar);
-	void glDetachShader_enc(void *self , GLuint program, GLuint shader);
-	void glDisable_enc(void *self , GLenum cap);
-	void glDisableVertexAttribArray_enc(void *self , GLuint index);
-	void glDrawArrays_enc(void *self , GLenum mode, GLint first, GLsizei count);
-	void glDrawElements_enc(void *self , GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-	void glEnable_enc(void *self , GLenum cap);
-	void glEnableVertexAttribArray_enc(void *self , GLuint index);
-	void glFinish_enc(void *self );
-	void glFlush_enc(void *self );
-	void glFramebufferRenderbuffer_enc(void *self , GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-	void glFramebufferTexture2D_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-	void glFrontFace_enc(void *self , GLenum mode);
-	void glGenBuffers_enc(void *self , GLsizei n, GLuint* buffers);
-	void glGenerateMipmap_enc(void *self , GLenum target);
-	void glGenFramebuffers_enc(void *self , GLsizei n, GLuint* framebuffers);
-	void glGenRenderbuffers_enc(void *self , GLsizei n, GLuint* renderbuffers);
-	void glGenTextures_enc(void *self , GLsizei n, GLuint* textures);
-	void glGetActiveAttrib_enc(void *self , GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-	void glGetActiveUniform_enc(void *self , GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name);
-	void glGetAttachedShaders_enc(void *self , GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-	int glGetAttribLocation_enc(void *self , GLuint program, const GLchar* name);
-	void glGetBooleanv_enc(void *self , GLenum pname, GLboolean* params);
-	void glGetBufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params);
-	GLenum glGetError_enc(void *self );
-	void glGetFloatv_enc(void *self , GLenum pname, GLfloat* params);
-	void glGetFramebufferAttachmentParameteriv_enc(void *self , GLenum target, GLenum attachment, GLenum pname, GLint* params);
-	void glGetIntegerv_enc(void *self , GLenum pname, GLint* params);
-	void glGetProgramiv_enc(void *self , GLuint program, GLenum pname, GLint* params);
-	void glGetProgramInfoLog_enc(void *self , GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-	void glGetRenderbufferParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params);
-	void glGetShaderiv_enc(void *self , GLuint shader, GLenum pname, GLint* params);
-	void glGetShaderInfoLog_enc(void *self , GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog);
-	void glGetShaderPrecisionFormat_enc(void *self , GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-	void glGetShaderSource_enc(void *self , GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source);
-	const GLubyte* glGetString_enc(void *self , GLenum name);
-	void glGetTexParameterfv_enc(void *self , GLenum target, GLenum pname, GLfloat* params);
-	void glGetTexParameteriv_enc(void *self , GLenum target, GLenum pname, GLint* params);
-	void glGetUniformfv_enc(void *self , GLuint program, GLint location, GLfloat* params);
-	void glGetUniformiv_enc(void *self , GLuint program, GLint location, GLint* params);
-	int glGetUniformLocation_enc(void *self , GLuint program, const GLchar* name);
-	void glGetVertexAttribfv_enc(void *self , GLuint index, GLenum pname, GLfloat* params);
-	void glGetVertexAttribiv_enc(void *self , GLuint index, GLenum pname, GLint* params);
-	void glGetVertexAttribPointerv_enc(void *self , GLuint index, GLenum pname, GLvoid** pointer);
-	void glHint_enc(void *self , GLenum target, GLenum mode);
-	GLboolean glIsBuffer_enc(void *self , GLuint buffer);
-	GLboolean glIsEnabled_enc(void *self , GLenum cap);
-	GLboolean glIsFramebuffer_enc(void *self , GLuint framebuffer);
-	GLboolean glIsProgram_enc(void *self , GLuint program);
-	GLboolean glIsRenderbuffer_enc(void *self , GLuint renderbuffer);
-	GLboolean glIsShader_enc(void *self , GLuint shader);
-	GLboolean glIsTexture_enc(void *self , GLuint texture);
-	void glLineWidth_enc(void *self , GLfloat width);
-	void glLinkProgram_enc(void *self , GLuint program);
-	void glPixelStorei_enc(void *self , GLenum pname, GLint param);
-	void glPolygonOffset_enc(void *self , GLfloat factor, GLfloat units);
-	void glReadPixels_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-	void glReleaseShaderCompiler_enc(void *self );
-	void glRenderbufferStorage_enc(void *self , GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-	void glSampleCoverage_enc(void *self , GLclampf value, GLboolean invert);
-	void glScissor_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height);
-	void glShaderBinary_enc(void *self , GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length);
-	void glShaderSource_enc(void *self , GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length);
-	void glStencilFunc_enc(void *self , GLenum func, GLint ref, GLuint mask);
-	void glStencilFuncSeparate_enc(void *self , GLenum face, GLenum func, GLint ref, GLuint mask);
-	void glStencilMask_enc(void *self , GLuint mask);
-	void glStencilMaskSeparate_enc(void *self , GLenum face, GLuint mask);
-	void glStencilOp_enc(void *self , GLenum fail, GLenum zfail, GLenum zpass);
-	void glStencilOpSeparate_enc(void *self , GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-	void glTexImage2D_enc(void *self , GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-	void glTexParameterf_enc(void *self , GLenum target, GLenum pname, GLfloat param);
-	void glTexParameterfv_enc(void *self , GLenum target, GLenum pname, const GLfloat* params);
-	void glTexParameteri_enc(void *self , GLenum target, GLenum pname, GLint param);
-	void glTexParameteriv_enc(void *self , GLenum target, GLenum pname, const GLint* params);
-	void glTexSubImage2D_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-	void glUniform1f_enc(void *self , GLint location, GLfloat x);
-	void glUniform1fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v);
-	void glUniform1i_enc(void *self , GLint location, GLint x);
-	void glUniform1iv_enc(void *self , GLint location, GLsizei count, const GLint* v);
-	void glUniform2f_enc(void *self , GLint location, GLfloat x, GLfloat y);
-	void glUniform2fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v);
-	void glUniform2i_enc(void *self , GLint location, GLint x, GLint y);
-	void glUniform2iv_enc(void *self , GLint location, GLsizei count, const GLint* v);
-	void glUniform3f_enc(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z);
-	void glUniform3fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v);
-	void glUniform3i_enc(void *self , GLint location, GLint x, GLint y, GLint z);
-	void glUniform3iv_enc(void *self , GLint location, GLsizei count, const GLint* v);
-	void glUniform4f_enc(void *self , GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-	void glUniform4fv_enc(void *self , GLint location, GLsizei count, const GLfloat* v);
-	void glUniform4i_enc(void *self , GLint location, GLint x, GLint y, GLint z, GLint w);
-	void glUniform4iv_enc(void *self , GLint location, GLsizei count, const GLint* v);
-	void glUniformMatrix2fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-	void glUniformMatrix3fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-	void glUniformMatrix4fv_enc(void *self , GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-	void glUseProgram_enc(void *self , GLuint program);
-	void glValidateProgram_enc(void *self , GLuint program);
-	void glVertexAttrib1f_enc(void *self , GLuint indx, GLfloat x);
-	void glVertexAttrib1fv_enc(void *self , GLuint indx, const GLfloat* values);
-	void glVertexAttrib2f_enc(void *self , GLuint indx, GLfloat x, GLfloat y);
-	void glVertexAttrib2fv_enc(void *self , GLuint indx, const GLfloat* values);
-	void glVertexAttrib3f_enc(void *self , GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-	void glVertexAttrib3fv_enc(void *self , GLuint indx, const GLfloat* values);
-	void glVertexAttrib4f_enc(void *self , GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-	void glVertexAttrib4fv_enc(void *self , GLuint indx, const GLfloat* values);
-	void glVertexAttribPointer_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr);
-	void glViewport_enc(void *self , GLint x, GLint y, GLsizei width, GLsizei height);
-	void glEGLImageTargetTexture2DOES_enc(void *self , GLenum target, GLeglImageOES image);
-	void glEGLImageTargetRenderbufferStorageOES_enc(void *self , GLenum target, GLeglImageOES image);
-	void glGetProgramBinaryOES_enc(void *self , GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary);
-	void glProgramBinaryOES_enc(void *self , GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length);
-	void* glMapBufferOES_enc(void *self , GLenum target, GLenum access);
-	GLboolean glUnmapBufferOES_enc(void *self , GLenum target);
-	void glTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-	void glTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels);
-	void glCopyTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-	void glCompressedTexImage3DOES_enc(void *self , GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data);
-	void glCompressedTexSubImage3DOES_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data);
-	void glFramebufferTexture3DOES_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-	void glBindVertexArrayOES_enc(void *self , GLuint array);
-	void glDeleteVertexArraysOES_enc(void *self , GLsizei n, const GLuint* arrays);
-	void glGenVertexArraysOES_enc(void *self , GLsizei n, GLuint* arrays);
-	GLboolean glIsVertexArrayOES_enc(void *self , GLuint array);
-	void glDiscardFramebufferEXT_enc(void *self , GLenum target, GLsizei numAttachments, const GLenum* attachments);
-	void glMultiDrawArraysEXT_enc(void *self , GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount);
-	void glMultiDrawElementsEXT_enc(void *self , GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount);
-	void glGetPerfMonitorGroupsAMD_enc(void *self , GLint* numGroups, GLsizei groupsSize, GLuint* groups);
-	void glGetPerfMonitorCountersAMD_enc(void *self , GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters);
-	void glGetPerfMonitorGroupStringAMD_enc(void *self , GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString);
-	void glGetPerfMonitorCounterStringAMD_enc(void *self , GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString);
-	void glGetPerfMonitorCounterInfoAMD_enc(void *self , GLuint group, GLuint counter, GLenum pname, GLvoid* data);
-	void glGenPerfMonitorsAMD_enc(void *self , GLsizei n, GLuint* monitors);
-	void glDeletePerfMonitorsAMD_enc(void *self , GLsizei n, GLuint* monitors);
-	void glSelectPerfMonitorCountersAMD_enc(void *self , GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList);
-	void glBeginPerfMonitorAMD_enc(void *self , GLuint monitor);
-	void glEndPerfMonitorAMD_enc(void *self , GLuint monitor);
-	void glGetPerfMonitorCounterDataAMD_enc(void *self , GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten);
-	void glRenderbufferStorageMultisampleIMG_enc(void *self , GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-	void glFramebufferTexture2DMultisampleIMG_enc(void *self , GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples);
-	void glDeleteFencesNV_enc(void *self , GLsizei n, const GLuint* fences);
-	void glGenFencesNV_enc(void *self , GLsizei n, GLuint* fences);
-	GLboolean glIsFenceNV_enc(void *self , GLuint fence);
-	GLboolean glTestFenceNV_enc(void *self , GLuint fence);
-	void glGetFenceivNV_enc(void *self , GLuint fence, GLenum pname, GLint* params);
-	void glFinishFenceNV_enc(void *self , GLuint fence);
-	void glSetFenceNV_enc(void *self , GLuint fence, GLenum condition);
-	void glCoverageMaskNV_enc(void *self , GLboolean mask);
-	void glCoverageOperationNV_enc(void *self , GLenum operation);
-	void glGetDriverControlsQCOM_enc(void *self , GLint* num, GLsizei size, GLuint* driverControls);
-	void glGetDriverControlStringQCOM_enc(void *self , GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString);
-	void glEnableDriverControlQCOM_enc(void *self , GLuint driverControl);
-	void glDisableDriverControlQCOM_enc(void *self , GLuint driverControl);
-	void glExtGetTexturesQCOM_enc(void *self , GLuint* textures, GLint maxTextures, GLint* numTextures);
-	void glExtGetBuffersQCOM_enc(void *self , GLuint* buffers, GLint maxBuffers, GLint* numBuffers);
-	void glExtGetRenderbuffersQCOM_enc(void *self , GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers);
-	void glExtGetFramebuffersQCOM_enc(void *self , GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers);
-	void glExtGetTexLevelParameterivQCOM_enc(void *self , GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params);
-	void glExtTexObjectStateOverrideiQCOM_enc(void *self , GLenum target, GLenum pname, GLint param);
-	void glExtGetTexSubImageQCOM_enc(void *self , GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels);
-	void glExtGetBufferPointervQCOM_enc(void *self , GLenum target, GLvoidptr* params);
-	void glExtGetShadersQCOM_enc(void *self , GLuint* shaders, GLint maxShaders, GLint* numShaders);
-	void glExtGetProgramsQCOM_enc(void *self , GLuint* programs, GLint maxPrograms, GLint* numPrograms);
-	GLboolean glExtIsProgramBinaryQCOM_enc(void *self , GLuint program);
-	void glExtGetProgramBinarySourceQCOM_enc(void *self , GLuint program, GLenum shadertype, GLchar* source, GLint* length);
-	void glStartTilingQCOM_enc(void *self , GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask);
-	void glEndTilingQCOM_enc(void *self , GLbitfield preserveMask);
-	void glVertexAttribPointerData_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen);
-	void glVertexAttribPointerOffset_enc(void *self , GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset);
-	void glDrawElementsOffset_enc(void *self , GLenum mode, GLsizei count, GLenum type, GLuint offset);
-	void glDrawElementsData_enc(void *self , GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen);
-	void glGetCompressedTextureFormats_enc(void *self , int count, GLint* formats);
-	void glShaderString_enc(void *self , GLuint shader, const GLchar* string, GLsizei len);
-	int glFinishRoundTrip_enc(void *self );
-};
-#endif
+#endif  // GUARD_gl2_encoder_context_t
\ No newline at end of file
diff --git a/opengl/system/GLESv2_enc/gl2_entry.cpp b/opengl/system/GLESv2_enc/gl2_entry.cpp
index b3ad229..3812aae 100644
--- a/opengl/system/GLESv2_enc/gl2_entry.cpp
+++ b/opengl/system/GLESv2_enc/gl2_entry.cpp
@@ -226,1258 +226,1258 @@ void gl2_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCur
 void glActiveTexture(GLenum texture)
 {
 	GET_CONTEXT;
-	 ctx->glActiveTexture(ctx, texture);
+	ctx->glActiveTexture(ctx, texture);
 }
 
 void glAttachShader(GLuint program, GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glAttachShader(ctx, program, shader);
+	ctx->glAttachShader(ctx, program, shader);
 }
 
 void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
 {
 	GET_CONTEXT;
-	 ctx->glBindAttribLocation(ctx, program, index, name);
+	ctx->glBindAttribLocation(ctx, program, index, name);
 }
 
 void glBindBuffer(GLenum target, GLuint buffer)
 {
 	GET_CONTEXT;
-	 ctx->glBindBuffer(ctx, target, buffer);
+	ctx->glBindBuffer(ctx, target, buffer);
 }
 
 void glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
 	GET_CONTEXT;
-	 ctx->glBindFramebuffer(ctx, target, framebuffer);
+	ctx->glBindFramebuffer(ctx, target, framebuffer);
 }
 
 void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
 	GET_CONTEXT;
-	 ctx->glBindRenderbuffer(ctx, target, renderbuffer);
+	ctx->glBindRenderbuffer(ctx, target, renderbuffer);
 }
 
 void glBindTexture(GLenum target, GLuint texture)
 {
 	GET_CONTEXT;
-	 ctx->glBindTexture(ctx, target, texture);
+	ctx->glBindTexture(ctx, target, texture);
 }
 
 void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
 	GET_CONTEXT;
-	 ctx->glBlendColor(ctx, red, green, blue, alpha);
+	ctx->glBlendColor(ctx, red, green, blue, alpha);
 }
 
 void glBlendEquation(GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glBlendEquation(ctx, mode);
+	ctx->glBlendEquation(ctx, mode);
 }
 
 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
 	GET_CONTEXT;
-	 ctx->glBlendEquationSeparate(ctx, modeRGB, modeAlpha);
+	ctx->glBlendEquationSeparate(ctx, modeRGB, modeAlpha);
 }
 
 void glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
 	GET_CONTEXT;
-	 ctx->glBlendFunc(ctx, sfactor, dfactor);
+	ctx->glBlendFunc(ctx, sfactor, dfactor);
 }
 
 void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
 	GET_CONTEXT;
-	 ctx->glBlendFuncSeparate(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
+	ctx->glBlendFuncSeparate(ctx, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
 {
 	GET_CONTEXT;
-	 ctx->glBufferData(ctx, target, size, data, usage);
+	ctx->glBufferData(ctx, target, size, data, usage);
 }
 
 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glBufferSubData(ctx, target, offset, size, data);
+	ctx->glBufferSubData(ctx, target, offset, size, data);
 }
 
 GLenum glCheckFramebufferStatus(GLenum target)
 {
 	GET_CONTEXT;
-	 return ctx->glCheckFramebufferStatus(ctx, target);
+	return ctx->glCheckFramebufferStatus(ctx, target);
 }
 
 void glClear(GLbitfield mask)
 {
 	GET_CONTEXT;
-	 ctx->glClear(ctx, mask);
+	ctx->glClear(ctx, mask);
 }
 
 void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
 	GET_CONTEXT;
-	 ctx->glClearColor(ctx, red, green, blue, alpha);
+	ctx->glClearColor(ctx, red, green, blue, alpha);
 }
 
 void glClearDepthf(GLclampf depth)
 {
 	GET_CONTEXT;
-	 ctx->glClearDepthf(ctx, depth);
+	ctx->glClearDepthf(ctx, depth);
 }
 
 void glClearStencil(GLint s)
 {
 	GET_CONTEXT;
-	 ctx->glClearStencil(ctx, s);
+	ctx->glClearStencil(ctx, s);
 }
 
 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
 	GET_CONTEXT;
-	 ctx->glColorMask(ctx, red, green, blue, alpha);
+	ctx->glColorMask(ctx, red, green, blue, alpha);
 }
 
 void glCompileShader(GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glCompileShader(ctx, shader);
+	ctx->glCompileShader(ctx, shader);
 }
 
 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
+	ctx->glCompressedTexImage2D(ctx, target, level, internalformat, width, height, border, imageSize, data);
 }
 
 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
+	ctx->glCompressedTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
 	GET_CONTEXT;
-	 ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
+	ctx->glCopyTexImage2D(ctx, target, level, internalformat, x, y, width, height, border);
 }
 
 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
+	ctx->glCopyTexSubImage2D(ctx, target, level, xoffset, yoffset, x, y, width, height);
 }
 
 GLuint glCreateProgram()
 {
 	GET_CONTEXT;
-	 return ctx->glCreateProgram(ctx);
+	return ctx->glCreateProgram(ctx);
 }
 
 GLuint glCreateShader(GLenum type)
 {
 	GET_CONTEXT;
-	 return ctx->glCreateShader(ctx, type);
+	return ctx->glCreateShader(ctx, type);
 }
 
 void glCullFace(GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glCullFace(ctx, mode);
+	ctx->glCullFace(ctx, mode);
 }
 
 void glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteBuffers(ctx, n, buffers);
+	ctx->glDeleteBuffers(ctx, n, buffers);
 }
 
 void glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteFramebuffers(ctx, n, framebuffers);
+	ctx->glDeleteFramebuffers(ctx, n, framebuffers);
 }
 
 void glDeleteProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glDeleteProgram(ctx, program);
+	ctx->glDeleteProgram(ctx, program);
 }
 
 void glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteRenderbuffers(ctx, n, renderbuffers);
+	ctx->glDeleteRenderbuffers(ctx, n, renderbuffers);
 }
 
 void glDeleteShader(GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glDeleteShader(ctx, shader);
+	ctx->glDeleteShader(ctx, shader);
 }
 
 void glDeleteTextures(GLsizei n, const GLuint* textures)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteTextures(ctx, n, textures);
+	ctx->glDeleteTextures(ctx, n, textures);
 }
 
 void glDepthFunc(GLenum func)
 {
 	GET_CONTEXT;
-	 ctx->glDepthFunc(ctx, func);
+	ctx->glDepthFunc(ctx, func);
 }
 
 void glDepthMask(GLboolean flag)
 {
 	GET_CONTEXT;
-	 ctx->glDepthMask(ctx, flag);
+	ctx->glDepthMask(ctx, flag);
 }
 
 void glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
 	GET_CONTEXT;
-	 ctx->glDepthRangef(ctx, zNear, zFar);
+	ctx->glDepthRangef(ctx, zNear, zFar);
 }
 
 void glDetachShader(GLuint program, GLuint shader)
 {
 	GET_CONTEXT;
-	 ctx->glDetachShader(ctx, program, shader);
+	ctx->glDetachShader(ctx, program, shader);
 }
 
 void glDisable(GLenum cap)
 {
 	GET_CONTEXT;
-	 ctx->glDisable(ctx, cap);
+	ctx->glDisable(ctx, cap);
 }
 
 void glDisableVertexAttribArray(GLuint index)
 {
 	GET_CONTEXT;
-	 ctx->glDisableVertexAttribArray(ctx, index);
+	ctx->glDisableVertexAttribArray(ctx, index);
 }
 
 void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
 	GET_CONTEXT;
-	 ctx->glDrawArrays(ctx, mode, first, count);
+	ctx->glDrawArrays(ctx, mode, first, count);
 }
 
 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
 {
 	GET_CONTEXT;
-	 ctx->glDrawElements(ctx, mode, count, type, indices);
+	ctx->glDrawElements(ctx, mode, count, type, indices);
 }
 
 void glEnable(GLenum cap)
 {
 	GET_CONTEXT;
-	 ctx->glEnable(ctx, cap);
+	ctx->glEnable(ctx, cap);
 }
 
 void glEnableVertexAttribArray(GLuint index)
 {
 	GET_CONTEXT;
-	 ctx->glEnableVertexAttribArray(ctx, index);
+	ctx->glEnableVertexAttribArray(ctx, index);
 }
 
 void glFinish()
 {
 	GET_CONTEXT;
-	 ctx->glFinish(ctx);
+	ctx->glFinish(ctx);
 }
 
 void glFlush()
 {
 	GET_CONTEXT;
-	 ctx->glFlush(ctx);
+	ctx->glFlush(ctx);
 }
 
 void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferRenderbuffer(ctx, target, attachment, renderbuffertarget, renderbuffer);
+	ctx->glFramebufferRenderbuffer(ctx, target, attachment, renderbuffertarget, renderbuffer);
 }
 
 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferTexture2D(ctx, target, attachment, textarget, texture, level);
+	ctx->glFramebufferTexture2D(ctx, target, attachment, textarget, texture, level);
 }
 
 void glFrontFace(GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glFrontFace(ctx, mode);
+	ctx->glFrontFace(ctx, mode);
 }
 
 void glGenBuffers(GLsizei n, GLuint* buffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenBuffers(ctx, n, buffers);
+	ctx->glGenBuffers(ctx, n, buffers);
 }
 
 void glGenerateMipmap(GLenum target)
 {
 	GET_CONTEXT;
-	 ctx->glGenerateMipmap(ctx, target);
+	ctx->glGenerateMipmap(ctx, target);
 }
 
 void glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenFramebuffers(ctx, n, framebuffers);
+	ctx->glGenFramebuffers(ctx, n, framebuffers);
 }
 
 void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenRenderbuffers(ctx, n, renderbuffers);
+	ctx->glGenRenderbuffers(ctx, n, renderbuffers);
 }
 
 void glGenTextures(GLsizei n, GLuint* textures)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenTextures(ctx, n, textures);
+	ctx->glGenTextures(ctx, n, textures);
 }
 
 void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
 {
 	GET_CONTEXT;
-	 ctx->glGetActiveAttrib(ctx, program, index, bufsize, length, size, type, name);
+	ctx->glGetActiveAttrib(ctx, program, index, bufsize, length, size, type, name);
 }
 
 void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
 {
 	GET_CONTEXT;
-	 ctx->glGetActiveUniform(ctx, program, index, bufsize, length, size, type, name);
+	ctx->glGetActiveUniform(ctx, program, index, bufsize, length, size, type, name);
 }
 
 void glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
 	GET_CONTEXT;
-	 ctx->glGetAttachedShaders(ctx, program, maxcount, count, shaders);
+	ctx->glGetAttachedShaders(ctx, program, maxcount, count, shaders);
 }
 
 int glGetAttribLocation(GLuint program, const GLchar* name)
 {
 	GET_CONTEXT;
-	 return ctx->glGetAttribLocation(ctx, program, name);
+	return ctx->glGetAttribLocation(ctx, program, name);
 }
 
 void glGetBooleanv(GLenum pname, GLboolean* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetBooleanv(ctx, pname, params);
+	ctx->glGetBooleanv(ctx, pname, params);
 }
 
 void glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetBufferParameteriv(ctx, target, pname, params);
+	ctx->glGetBufferParameteriv(ctx, target, pname, params);
 }
 
 GLenum glGetError()
 {
 	GET_CONTEXT;
-	 return ctx->glGetError(ctx);
+	return ctx->glGetError(ctx);
 }
 
 void glGetFloatv(GLenum pname, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetFloatv(ctx, pname, params);
+	ctx->glGetFloatv(ctx, pname, params);
 }
 
 void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetFramebufferAttachmentParameteriv(ctx, target, attachment, pname, params);
+	ctx->glGetFramebufferAttachmentParameteriv(ctx, target, attachment, pname, params);
 }
 
 void glGetIntegerv(GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetIntegerv(ctx, pname, params);
+	ctx->glGetIntegerv(ctx, pname, params);
 }
 
 void glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetProgramiv(ctx, program, pname, params);
+	ctx->glGetProgramiv(ctx, program, pname, params);
 }
 
 void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
 {
 	GET_CONTEXT;
-	 ctx->glGetProgramInfoLog(ctx, program, bufsize, length, infolog);
+	ctx->glGetProgramInfoLog(ctx, program, bufsize, length, infolog);
 }
 
 void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetRenderbufferParameteriv(ctx, target, pname, params);
+	ctx->glGetRenderbufferParameteriv(ctx, target, pname, params);
 }
 
 void glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderiv(ctx, shader, pname, params);
+	ctx->glGetShaderiv(ctx, shader, pname, params);
 }
 
 void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderInfoLog(ctx, shader, bufsize, length, infolog);
+	ctx->glGetShaderInfoLog(ctx, shader, bufsize, length, infolog);
 }
 
 void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderPrecisionFormat(ctx, shadertype, precisiontype, range, precision);
+	ctx->glGetShaderPrecisionFormat(ctx, shadertype, precisiontype, range, precision);
 }
 
 void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
 {
 	GET_CONTEXT;
-	 ctx->glGetShaderSource(ctx, shader, bufsize, length, source);
+	ctx->glGetShaderSource(ctx, shader, bufsize, length, source);
 }
 
 const GLubyte* glGetString(GLenum name)
 {
 	GET_CONTEXT;
-	 return ctx->glGetString(ctx, name);
+	return ctx->glGetString(ctx, name);
 }
 
 void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetTexParameterfv(ctx, target, pname, params);
+	ctx->glGetTexParameterfv(ctx, target, pname, params);
 }
 
 void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetTexParameteriv(ctx, target, pname, params);
+	ctx->glGetTexParameteriv(ctx, target, pname, params);
 }
 
 void glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetUniformfv(ctx, program, location, params);
+	ctx->glGetUniformfv(ctx, program, location, params);
 }
 
 void glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetUniformiv(ctx, program, location, params);
+	ctx->glGetUniformiv(ctx, program, location, params);
 }
 
 int glGetUniformLocation(GLuint program, const GLchar* name)
 {
 	GET_CONTEXT;
-	 return ctx->glGetUniformLocation(ctx, program, name);
+	return ctx->glGetUniformLocation(ctx, program, name);
 }
 
 void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetVertexAttribfv(ctx, index, pname, params);
+	ctx->glGetVertexAttribfv(ctx, index, pname, params);
 }
 
 void glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetVertexAttribiv(ctx, index, pname, params);
+	ctx->glGetVertexAttribiv(ctx, index, pname, params);
 }
 
 void glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
 {
 	GET_CONTEXT;
-	 ctx->glGetVertexAttribPointerv(ctx, index, pname, pointer);
+	ctx->glGetVertexAttribPointerv(ctx, index, pname, pointer);
 }
 
 void glHint(GLenum target, GLenum mode)
 {
 	GET_CONTEXT;
-	 ctx->glHint(ctx, target, mode);
+	ctx->glHint(ctx, target, mode);
 }
 
 GLboolean glIsBuffer(GLuint buffer)
 {
 	GET_CONTEXT;
-	 return ctx->glIsBuffer(ctx, buffer);
+	return ctx->glIsBuffer(ctx, buffer);
 }
 
 GLboolean glIsEnabled(GLenum cap)
 {
 	GET_CONTEXT;
-	 return ctx->glIsEnabled(ctx, cap);
+	return ctx->glIsEnabled(ctx, cap);
 }
 
 GLboolean glIsFramebuffer(GLuint framebuffer)
 {
 	GET_CONTEXT;
-	 return ctx->glIsFramebuffer(ctx, framebuffer);
+	return ctx->glIsFramebuffer(ctx, framebuffer);
 }
 
 GLboolean glIsProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 return ctx->glIsProgram(ctx, program);
+	return ctx->glIsProgram(ctx, program);
 }
 
 GLboolean glIsRenderbuffer(GLuint renderbuffer)
 {
 	GET_CONTEXT;
-	 return ctx->glIsRenderbuffer(ctx, renderbuffer);
+	return ctx->glIsRenderbuffer(ctx, renderbuffer);
 }
 
 GLboolean glIsShader(GLuint shader)
 {
 	GET_CONTEXT;
-	 return ctx->glIsShader(ctx, shader);
+	return ctx->glIsShader(ctx, shader);
 }
 
 GLboolean glIsTexture(GLuint texture)
 {
 	GET_CONTEXT;
-	 return ctx->glIsTexture(ctx, texture);
+	return ctx->glIsTexture(ctx, texture);
 }
 
 void glLineWidth(GLfloat width)
 {
 	GET_CONTEXT;
-	 ctx->glLineWidth(ctx, width);
+	ctx->glLineWidth(ctx, width);
 }
 
 void glLinkProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glLinkProgram(ctx, program);
+	ctx->glLinkProgram(ctx, program);
 }
 
 void glPixelStorei(GLenum pname, GLint param)
 {
 	GET_CONTEXT;
-	 ctx->glPixelStorei(ctx, pname, param);
+	ctx->glPixelStorei(ctx, pname, param);
 }
 
 void glPolygonOffset(GLfloat factor, GLfloat units)
 {
 	GET_CONTEXT;
-	 ctx->glPolygonOffset(ctx, factor, units);
+	ctx->glPolygonOffset(ctx, factor, units);
 }
 
 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
+	ctx->glReadPixels(ctx, x, y, width, height, format, type, pixels);
 }
 
 void glReleaseShaderCompiler()
 {
 	GET_CONTEXT;
-	 ctx->glReleaseShaderCompiler(ctx);
+	ctx->glReleaseShaderCompiler(ctx);
 }
 
 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glRenderbufferStorage(ctx, target, internalformat, width, height);
+	ctx->glRenderbufferStorage(ctx, target, internalformat, width, height);
 }
 
 void glSampleCoverage(GLclampf value, GLboolean invert)
 {
 	GET_CONTEXT;
-	 ctx->glSampleCoverage(ctx, value, invert);
+	ctx->glSampleCoverage(ctx, value, invert);
 }
 
 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glScissor(ctx, x, y, width, height);
+	ctx->glScissor(ctx, x, y, width, height);
 }
 
 void glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
 {
 	GET_CONTEXT;
-	 ctx->glShaderBinary(ctx, n, shaders, binaryformat, binary, length);
+	ctx->glShaderBinary(ctx, n, shaders, binaryformat, binary, length);
 }
 
 void glShaderSource(GLuint shader, GLsizei count, const GLchar* const* string, const GLint* length)
 {
 	GET_CONTEXT;
-	 ctx->glShaderSource(ctx, shader, count, string, length);
+	ctx->glShaderSource(ctx, shader, count, string, length);
 }
 
 void glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilFunc(ctx, func, ref, mask);
+	ctx->glStencilFunc(ctx, func, ref, mask);
 }
 
 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilFuncSeparate(ctx, face, func, ref, mask);
+	ctx->glStencilFuncSeparate(ctx, face, func, ref, mask);
 }
 
 void glStencilMask(GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilMask(ctx, mask);
+	ctx->glStencilMask(ctx, mask);
 }
 
 void glStencilMaskSeparate(GLenum face, GLuint mask)
 {
 	GET_CONTEXT;
-	 ctx->glStencilMaskSeparate(ctx, face, mask);
+	ctx->glStencilMaskSeparate(ctx, face, mask);
 }
 
 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
 	GET_CONTEXT;
-	 ctx->glStencilOp(ctx, fail, zfail, zpass);
+	ctx->glStencilOp(ctx, fail, zfail, zpass);
 }
 
 void glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
 	GET_CONTEXT;
-	 ctx->glStencilOpSeparate(ctx, face, fail, zfail, zpass);
+	ctx->glStencilOpSeparate(ctx, face, fail, zfail, zpass);
 }
 
 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
+	ctx->glTexImage2D(ctx, target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameterf(ctx, target, pname, param);
+	ctx->glTexParameterf(ctx, target, pname, param);
 }
 
 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameterfv(ctx, target, pname, params);
+	ctx->glTexParameterfv(ctx, target, pname, params);
 }
 
 void glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameteri(ctx, target, pname, param);
+	ctx->glTexParameteri(ctx, target, pname, param);
 }
 
 void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glTexParameteriv(ctx, target, pname, params);
+	ctx->glTexParameteriv(ctx, target, pname, params);
 }
 
 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
+	ctx->glTexSubImage2D(ctx, target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void glUniform1f(GLint location, GLfloat x)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1f(ctx, location, x);
+	ctx->glUniform1f(ctx, location, x);
 }
 
 void glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1fv(ctx, location, count, v);
+	ctx->glUniform1fv(ctx, location, count, v);
 }
 
 void glUniform1i(GLint location, GLint x)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1i(ctx, location, x);
+	ctx->glUniform1i(ctx, location, x);
 }
 
 void glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform1iv(ctx, location, count, v);
+	ctx->glUniform1iv(ctx, location, count, v);
 }
 
 void glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2f(ctx, location, x, y);
+	ctx->glUniform2f(ctx, location, x, y);
 }
 
 void glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2fv(ctx, location, count, v);
+	ctx->glUniform2fv(ctx, location, count, v);
 }
 
 void glUniform2i(GLint location, GLint x, GLint y)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2i(ctx, location, x, y);
+	ctx->glUniform2i(ctx, location, x, y);
 }
 
 void glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform2iv(ctx, location, count, v);
+	ctx->glUniform2iv(ctx, location, count, v);
 }
 
 void glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3f(ctx, location, x, y, z);
+	ctx->glUniform3f(ctx, location, x, y, z);
 }
 
 void glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3fv(ctx, location, count, v);
+	ctx->glUniform3fv(ctx, location, count, v);
 }
 
 void glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3i(ctx, location, x, y, z);
+	ctx->glUniform3i(ctx, location, x, y, z);
 }
 
 void glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform3iv(ctx, location, count, v);
+	ctx->glUniform3iv(ctx, location, count, v);
 }
 
 void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4f(ctx, location, x, y, z, w);
+	ctx->glUniform4f(ctx, location, x, y, z, w);
 }
 
 void glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4fv(ctx, location, count, v);
+	ctx->glUniform4fv(ctx, location, count, v);
 }
 
 void glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4i(ctx, location, x, y, z, w);
+	ctx->glUniform4i(ctx, location, x, y, z, w);
 }
 
 void glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
 	GET_CONTEXT;
-	 ctx->glUniform4iv(ctx, location, count, v);
+	ctx->glUniform4iv(ctx, location, count, v);
 }
 
 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
 	GET_CONTEXT;
-	 ctx->glUniformMatrix2fv(ctx, location, count, transpose, value);
+	ctx->glUniformMatrix2fv(ctx, location, count, transpose, value);
 }
 
 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
 	GET_CONTEXT;
-	 ctx->glUniformMatrix3fv(ctx, location, count, transpose, value);
+	ctx->glUniformMatrix3fv(ctx, location, count, transpose, value);
 }
 
 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
 	GET_CONTEXT;
-	 ctx->glUniformMatrix4fv(ctx, location, count, transpose, value);
+	ctx->glUniformMatrix4fv(ctx, location, count, transpose, value);
 }
 
 void glUseProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glUseProgram(ctx, program);
+	ctx->glUseProgram(ctx, program);
 }
 
 void glValidateProgram(GLuint program)
 {
 	GET_CONTEXT;
-	 ctx->glValidateProgram(ctx, program);
+	ctx->glValidateProgram(ctx, program);
 }
 
 void glVertexAttrib1f(GLuint indx, GLfloat x)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib1f(ctx, indx, x);
+	ctx->glVertexAttrib1f(ctx, indx, x);
 }
 
 void glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib1fv(ctx, indx, values);
+	ctx->glVertexAttrib1fv(ctx, indx, values);
 }
 
 void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib2f(ctx, indx, x, y);
+	ctx->glVertexAttrib2f(ctx, indx, x, y);
 }
 
 void glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib2fv(ctx, indx, values);
+	ctx->glVertexAttrib2fv(ctx, indx, values);
 }
 
 void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib3f(ctx, indx, x, y, z);
+	ctx->glVertexAttrib3f(ctx, indx, x, y, z);
 }
 
 void glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib3fv(ctx, indx, values);
+	ctx->glVertexAttrib3fv(ctx, indx, values);
 }
 
 void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib4f(ctx, indx, x, y, z, w);
+	ctx->glVertexAttrib4f(ctx, indx, x, y, z, w);
 }
 
 void glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttrib4fv(ctx, indx, values);
+	ctx->glVertexAttrib4fv(ctx, indx, values);
 }
 
 void glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttribPointer(ctx, indx, size, type, normalized, stride, ptr);
+	ctx->glVertexAttribPointer(ctx, indx, size, type, normalized, stride, ptr);
 }
 
 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glViewport(ctx, x, y, width, height);
+	ctx->glViewport(ctx, x, y, width, height);
 }
 
 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
 {
 	GET_CONTEXT;
-	 ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
+	ctx->glEGLImageTargetTexture2DOES(ctx, target, image);
 }
 
 void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
 {
 	GET_CONTEXT;
-	 ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
+	ctx->glEGLImageTargetRenderbufferStorageOES(ctx, target, image);
 }
 
 void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
 {
 	GET_CONTEXT;
-	 ctx->glGetProgramBinaryOES(ctx, program, bufSize, length, binaryFormat, binary);
+	ctx->glGetProgramBinaryOES(ctx, program, bufSize, length, binaryFormat, binary);
 }
 
 void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLint length)
 {
 	GET_CONTEXT;
-	 ctx->glProgramBinaryOES(ctx, program, binaryFormat, binary, length);
+	ctx->glProgramBinaryOES(ctx, program, binaryFormat, binary, length);
 }
 
 void* glMapBufferOES(GLenum target, GLenum access)
 {
 	GET_CONTEXT;
-	 return ctx->glMapBufferOES(ctx, target, access);
+	return ctx->glMapBufferOES(ctx, target, access);
 }
 
 GLboolean glUnmapBufferOES(GLenum target)
 {
 	GET_CONTEXT;
-	 return ctx->glUnmapBufferOES(ctx, target);
+	return ctx->glUnmapBufferOES(ctx, target);
 }
 
 void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, format, type, pixels);
+	ctx->glTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
 {
 	GET_CONTEXT;
-	 ctx->glTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+	ctx->glTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 void glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glCopyTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, x, y, width, height);
+	ctx->glCopyTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glCompressedTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, imageSize, data);
+	ctx->glCompressedTexImage3DOES(ctx, target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glCompressedTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+	ctx->glCompressedTexSubImage3DOES(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferTexture3DOES(ctx, target, attachment, textarget, texture, level, zoffset);
+	ctx->glFramebufferTexture3DOES(ctx, target, attachment, textarget, texture, level, zoffset);
 }
 
 void glBindVertexArrayOES(GLuint array)
 {
 	GET_CONTEXT;
-	 ctx->glBindVertexArrayOES(ctx, array);
+	ctx->glBindVertexArrayOES(ctx, array);
 }
 
 void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glDeleteVertexArraysOES(ctx, n, arrays);
+	ctx->glDeleteVertexArraysOES(ctx, n, arrays);
 }
 
 void glGenVertexArraysOES(GLsizei n, GLuint* arrays)
 {
 	GET_CONTEXT;
 	 if(n<0){ ctx->setError(GL_INVALID_VALUE); return; }
-	 ctx->glGenVertexArraysOES(ctx, n, arrays);
+	ctx->glGenVertexArraysOES(ctx, n, arrays);
 }
 
 GLboolean glIsVertexArrayOES(GLuint array)
 {
 	GET_CONTEXT;
-	 return ctx->glIsVertexArrayOES(ctx, array);
+	return ctx->glIsVertexArrayOES(ctx, array);
 }
 
 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum* attachments)
 {
 	GET_CONTEXT;
-	 ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
+	ctx->glDiscardFramebufferEXT(ctx, target, numAttachments, attachments);
 }
 
 void glMultiDrawArraysEXT(GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount)
 {
 	GET_CONTEXT;
-	 ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
+	ctx->glMultiDrawArraysEXT(ctx, mode, first, count, primcount);
 }
 
 void glMultiDrawElementsEXT(GLenum mode, const GLsizei* count, GLenum type, const GLvoid* const* indices, GLsizei primcount)
 {
 	GET_CONTEXT;
-	 ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
+	ctx->glMultiDrawElementsEXT(ctx, mode, count, type, indices, primcount);
 }
 
 void glGetPerfMonitorGroupsAMD(GLint* numGroups, GLsizei groupsSize, GLuint* groups)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorGroupsAMD(ctx, numGroups, groupsSize, groups);
+	ctx->glGetPerfMonitorGroupsAMD(ctx, numGroups, groupsSize, groups);
 }
 
 void glGetPerfMonitorCountersAMD(GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCountersAMD(ctx, group, numCounters, maxActiveCounters, counterSize, counters);
+	ctx->glGetPerfMonitorCountersAMD(ctx, group, numCounters, maxActiveCounters, counterSize, counters);
 }
 
 void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorGroupStringAMD(ctx, group, bufSize, length, groupString);
+	ctx->glGetPerfMonitorGroupStringAMD(ctx, group, bufSize, length, groupString);
 }
 
 void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCounterStringAMD(ctx, group, counter, bufSize, length, counterString);
+	ctx->glGetPerfMonitorCounterStringAMD(ctx, group, counter, bufSize, length, counterString);
 }
 
 void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid* data)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCounterInfoAMD(ctx, group, counter, pname, data);
+	ctx->glGetPerfMonitorCounterInfoAMD(ctx, group, counter, pname, data);
 }
 
 void glGenPerfMonitorsAMD(GLsizei n, GLuint* monitors)
 {
 	GET_CONTEXT;
-	 ctx->glGenPerfMonitorsAMD(ctx, n, monitors);
+	ctx->glGenPerfMonitorsAMD(ctx, n, monitors);
 }
 
 void glDeletePerfMonitorsAMD(GLsizei n, GLuint* monitors)
 {
 	GET_CONTEXT;
-	 ctx->glDeletePerfMonitorsAMD(ctx, n, monitors);
+	ctx->glDeletePerfMonitorsAMD(ctx, n, monitors);
 }
 
 void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* countersList)
 {
 	GET_CONTEXT;
-	 ctx->glSelectPerfMonitorCountersAMD(ctx, monitor, enable, group, numCounters, countersList);
+	ctx->glSelectPerfMonitorCountersAMD(ctx, monitor, enable, group, numCounters, countersList);
 }
 
 void glBeginPerfMonitorAMD(GLuint monitor)
 {
 	GET_CONTEXT;
-	 ctx->glBeginPerfMonitorAMD(ctx, monitor);
+	ctx->glBeginPerfMonitorAMD(ctx, monitor);
 }
 
 void glEndPerfMonitorAMD(GLuint monitor)
 {
 	GET_CONTEXT;
-	 ctx->glEndPerfMonitorAMD(ctx, monitor);
+	ctx->glEndPerfMonitorAMD(ctx, monitor);
 }
 
 void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten)
 {
 	GET_CONTEXT;
-	 ctx->glGetPerfMonitorCounterDataAMD(ctx, monitor, pname, dataSize, data, bytesWritten);
+	ctx->glGetPerfMonitorCounterDataAMD(ctx, monitor, pname, dataSize, data, bytesWritten);
 }
 
 void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
 	GET_CONTEXT;
-	 ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
+	ctx->glRenderbufferStorageMultisampleIMG(ctx, target, samples, internalformat, width, height);
 }
 
 void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples)
 {
 	GET_CONTEXT;
-	 ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
+	ctx->glFramebufferTexture2DMultisampleIMG(ctx, target, attachment, textarget, texture, level, samples);
 }
 
 void glDeleteFencesNV(GLsizei n, const GLuint* fences)
 {
 	GET_CONTEXT;
-	 ctx->glDeleteFencesNV(ctx, n, fences);
+	ctx->glDeleteFencesNV(ctx, n, fences);
 }
 
 void glGenFencesNV(GLsizei n, GLuint* fences)
 {
 	GET_CONTEXT;
-	 ctx->glGenFencesNV(ctx, n, fences);
+	ctx->glGenFencesNV(ctx, n, fences);
 }
 
 GLboolean glIsFenceNV(GLuint fence)
 {
 	GET_CONTEXT;
-	 return ctx->glIsFenceNV(ctx, fence);
+	return ctx->glIsFenceNV(ctx, fence);
 }
 
 GLboolean glTestFenceNV(GLuint fence)
 {
 	GET_CONTEXT;
-	 return ctx->glTestFenceNV(ctx, fence);
+	return ctx->glTestFenceNV(ctx, fence);
 }
 
 void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glGetFenceivNV(ctx, fence, pname, params);
+	ctx->glGetFenceivNV(ctx, fence, pname, params);
 }
 
 void glFinishFenceNV(GLuint fence)
 {
 	GET_CONTEXT;
-	 ctx->glFinishFenceNV(ctx, fence);
+	ctx->glFinishFenceNV(ctx, fence);
 }
 
 void glSetFenceNV(GLuint fence, GLenum condition)
 {
 	GET_CONTEXT;
-	 ctx->glSetFenceNV(ctx, fence, condition);
+	ctx->glSetFenceNV(ctx, fence, condition);
 }
 
 void glCoverageMaskNV(GLboolean mask)
 {
 	GET_CONTEXT;
-	 ctx->glCoverageMaskNV(ctx, mask);
+	ctx->glCoverageMaskNV(ctx, mask);
 }
 
 void glCoverageOperationNV(GLenum operation)
 {
 	GET_CONTEXT;
-	 ctx->glCoverageOperationNV(ctx, operation);
+	ctx->glCoverageOperationNV(ctx, operation);
 }
 
 void glGetDriverControlsQCOM(GLint* num, GLsizei size, GLuint* driverControls)
 {
 	GET_CONTEXT;
-	 ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
+	ctx->glGetDriverControlsQCOM(ctx, num, size, driverControls);
 }
 
 void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar* driverControlString)
 {
 	GET_CONTEXT;
-	 ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
+	ctx->glGetDriverControlStringQCOM(ctx, driverControl, bufSize, length, driverControlString);
 }
 
 void glEnableDriverControlQCOM(GLuint driverControl)
 {
 	GET_CONTEXT;
-	 ctx->glEnableDriverControlQCOM(ctx, driverControl);
+	ctx->glEnableDriverControlQCOM(ctx, driverControl);
 }
 
 void glDisableDriverControlQCOM(GLuint driverControl)
 {
 	GET_CONTEXT;
-	 ctx->glDisableDriverControlQCOM(ctx, driverControl);
+	ctx->glDisableDriverControlQCOM(ctx, driverControl);
 }
 
 void glExtGetTexturesQCOM(GLuint* textures, GLint maxTextures, GLint* numTextures)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
+	ctx->glExtGetTexturesQCOM(ctx, textures, maxTextures, numTextures);
 }
 
 void glExtGetBuffersQCOM(GLuint* buffers, GLint maxBuffers, GLint* numBuffers)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
+	ctx->glExtGetBuffersQCOM(ctx, buffers, maxBuffers, numBuffers);
 }
 
 void glExtGetRenderbuffersQCOM(GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
+	ctx->glExtGetRenderbuffersQCOM(ctx, renderbuffers, maxRenderbuffers, numRenderbuffers);
 }
 
 void glExtGetFramebuffersQCOM(GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
+	ctx->glExtGetFramebuffersQCOM(ctx, framebuffers, maxFramebuffers, numFramebuffers);
 }
 
 void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
+	ctx->glExtGetTexLevelParameterivQCOM(ctx, texture, face, level, pname, params);
 }
 
 void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param)
 {
 	GET_CONTEXT;
-	 ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
+	ctx->glExtTexObjectStateOverrideiQCOM(ctx, target, pname, param);
 }
 
 void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* texels)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
+	ctx->glExtGetTexSubImageQCOM(ctx, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels);
 }
 
 void glExtGetBufferPointervQCOM(GLenum target, GLvoidptr* params)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetBufferPointervQCOM(ctx, target, params);
+	ctx->glExtGetBufferPointervQCOM(ctx, target, params);
 }
 
 void glExtGetShadersQCOM(GLuint* shaders, GLint maxShaders, GLint* numShaders)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
+	ctx->glExtGetShadersQCOM(ctx, shaders, maxShaders, numShaders);
 }
 
 void glExtGetProgramsQCOM(GLuint* programs, GLint maxPrograms, GLint* numPrograms)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
+	ctx->glExtGetProgramsQCOM(ctx, programs, maxPrograms, numPrograms);
 }
 
 GLboolean glExtIsProgramBinaryQCOM(GLuint program)
 {
 	GET_CONTEXT;
-	 return ctx->glExtIsProgramBinaryQCOM(ctx, program);
+	return ctx->glExtIsProgramBinaryQCOM(ctx, program);
 }
 
 void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar* source, GLint* length)
 {
 	GET_CONTEXT;
-	 ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
+	ctx->glExtGetProgramBinarySourceQCOM(ctx, program, shadertype, source, length);
 }
 
 void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask)
 {
 	GET_CONTEXT;
-	 ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
+	ctx->glStartTilingQCOM(ctx, x, y, width, height, preserveMask);
 }
 
 void glEndTilingQCOM(GLbitfield preserveMask)
 {
 	GET_CONTEXT;
-	 ctx->glEndTilingQCOM(ctx, preserveMask);
+	ctx->glEndTilingQCOM(ctx, preserveMask);
 }
 
 void glVertexAttribPointerData(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, void* data, GLuint datalen)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttribPointerData(ctx, indx, size, type, normalized, stride, data, datalen);
+	ctx->glVertexAttribPointerData(ctx, indx, size, type, normalized, stride, data, datalen);
 }
 
 void glVertexAttribPointerOffset(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint offset)
 {
 	GET_CONTEXT;
-	 ctx->glVertexAttribPointerOffset(ctx, indx, size, type, normalized, stride, offset);
+	ctx->glVertexAttribPointerOffset(ctx, indx, size, type, normalized, stride, offset);
 }
 
 void glDrawElementsOffset(GLenum mode, GLsizei count, GLenum type, GLuint offset)
 {
 	GET_CONTEXT;
-	 ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
+	ctx->glDrawElementsOffset(ctx, mode, count, type, offset);
 }
 
 void glDrawElementsData(GLenum mode, GLsizei count, GLenum type, void* data, GLuint datalen)
 {
 	GET_CONTEXT;
-	 ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
+	ctx->glDrawElementsData(ctx, mode, count, type, data, datalen);
 }
 
 void glGetCompressedTextureFormats(int count, GLint* formats)
 {
 	GET_CONTEXT;
-	 ctx->glGetCompressedTextureFormats(ctx, count, formats);
+	ctx->glGetCompressedTextureFormats(ctx, count, formats);
 }
 
 void glShaderString(GLuint shader, const GLchar* string, GLsizei len)
 {
 	GET_CONTEXT;
-	 ctx->glShaderString(ctx, shader, string, len);
+	ctx->glShaderString(ctx, shader, string, len);
 }
 
 int glFinishRoundTrip()
 {
 	GET_CONTEXT;
-	 return ctx->glFinishRoundTrip(ctx);
+	return ctx->glFinishRoundTrip(ctx);
 }
 
diff --git a/opengl/system/GLESv2_enc/gl2_ftable.h b/opengl/system/GLESv2_enc/gl2_ftable.h
index 4cbda78..25df4f0 100644
--- a/opengl/system/GLESv2_enc/gl2_ftable.h
+++ b/opengl/system/GLESv2_enc/gl2_ftable.h
@@ -4,7 +4,7 @@
 #define __gl2_client_ftable_t_h
 
 
-static struct _gl2_funcs_by_name {
+static const struct _gl2_funcs_by_name {
 	const char *name;
 	void *proc;
 } gl2_funcs_by_name[] = {
@@ -210,7 +210,7 @@ static struct _gl2_funcs_by_name {
 	{"glStartTilingQCOM", (void*)glStartTilingQCOM},
 	{"glEndTilingQCOM", (void*)glEndTilingQCOM},
 };
-static int gl2_num_funcs = sizeof(gl2_funcs_by_name) / sizeof(struct _gl2_funcs_by_name);
+static const int gl2_num_funcs = sizeof(gl2_funcs_by_name) / sizeof(struct _gl2_funcs_by_name);
 
 
 #endif
diff --git a/opengl/system/OpenglSystemCommon/ThreadInfo.cpp b/opengl/system/OpenglSystemCommon/ThreadInfo.cpp
index f9c8521..04ce508 100644
--- a/opengl/system/OpenglSystemCommon/ThreadInfo.cpp
+++ b/opengl/system/OpenglSystemCommon/ThreadInfo.cpp
@@ -24,7 +24,7 @@ static void tlsDestruct(void *ptr)
         EGLThreadInfo *ti = (EGLThreadInfo *)ptr;
         delete ti->hostConn;
         delete ti;
-        ((intptr_t *)__get_tls())[TLS_SLOT_OPENGL] = NULL;
+        ((void **)__get_tls())[TLS_SLOT_OPENGL] = NULL;
     }
 }
 
diff --git a/opengl/system/egl/egl.cpp b/opengl/system/egl/egl.cpp
index daa52de..8499229 100644
--- a/opengl/system/egl/egl.cpp
+++ b/opengl/system/egl/egl.cpp
@@ -140,7 +140,8 @@ EGLContext_t::EGLContext_t(EGLDisplay dpy, EGLConfig config, EGLContext_t* share
     versionString(NULL),
     vendorString(NULL),
     rendererString(NULL),
-    extensionString(NULL)
+    extensionString(NULL),
+    deletePending(0)
 {
     flags = 0;
     version = 1;
@@ -336,7 +337,7 @@ struct egl_pbuffer_surface_t : public egl_surface_t {
 
     virtual ~egl_pbuffer_surface_t();
 
-    virtual void       setSwapInterval(int interval) {}
+    virtual void       setSwapInterval(int interval) { (void)interval; }
     virtual EGLBoolean swapBuffers() { return EGL_TRUE; }
 
     uint32_t getRcColorBuffer() { return rcColorBuffer; }
@@ -542,7 +543,7 @@ const char* eglQueryString(EGLDisplay dpy, EGLint name)
 
 EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
 {
-    VALIDATE_DISPLAY_INIT(dpy, NULL);
+    VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE);
 
     if(!num_config) {
         RETURN_ERROR(EGL_FALSE,EGL_BAD_PARAMETER);
@@ -554,9 +555,9 @@ EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size,
         return EGL_TRUE;
     }
 
-    uintptr_t i=0;
-    for (i=0 ; i<numConfigs && i<config_size ; i++) {
-        *configs++ = (EGLConfig)i;
+    EGLint i;
+    for (i = 0 ; i < numConfigs && i < config_size ; i++) {
+        *configs++ = (EGLConfig)(uintptr_t)i;
     }
     *num_config = i;
     return EGL_TRUE;
@@ -593,7 +594,7 @@ EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig
 
 EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
 {
-    VALIDATE_DISPLAY_INIT(dpy, NULL);
+    VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE);
     VALIDATE_CONFIG(config, EGL_FALSE);
 
     if (s_display.getConfigAttrib(config, attribute, value))
@@ -608,6 +609,8 @@ EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute
 
 EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list)
 {
+    (void)attrib_list;
+
     VALIDATE_DISPLAY_INIT(dpy, NULL);
     VALIDATE_CONFIG(config, EGL_FALSE);
     if (win == 0) {
@@ -699,6 +702,10 @@ EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePix
     //     to s/w rendering -or- let the host render to a buffer that will be
     //     copied back to guest at some sync point. None of those methods not
     //     implemented and pixmaps are not used with OpenGL anyway ...
+    (void)dpy;
+    (void)config;
+    (void)pixmap;
+    (void)attrib_list;
     return EGL_NO_SURFACE;
 }
 
@@ -783,6 +790,11 @@ EGLBoolean eglReleaseThread()
 EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
 {
     //TODO
+    (void)dpy;
+    (void)buftype;
+    (void)buffer;
+    (void)config;
+    (void)attrib_list;
     ALOGW("%s not implemented", __FUNCTION__);
     return 0;
 }
@@ -790,6 +802,10 @@ EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGL
 EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
 {
     //TODO
+    (void)dpy;
+    (void)surface;
+    (void)attribute;
+    (void)value;
     ALOGW("%s not implemented", __FUNCTION__);
     return 0;
 }
@@ -828,6 +844,9 @@ EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface eglSurface, EGLint buffer)
 EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
     //TODO
+    (void)dpy;
+    (void)surface;
+    (void)buffer;
     ALOGW("%s not implemented", __FUNCTION__);
     return 0;
 }
@@ -897,9 +916,11 @@ EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 
     EGLContext_t * context = static_cast<EGLContext_t*>(ctx);
 
-    if (getEGLThreadInfo()->currentContext == context)
-    {
-        eglMakeCurrent(dpy, EGL_NO_CONTEXT, EGL_NO_SURFACE, EGL_NO_SURFACE);
+    if (!context) return EGL_TRUE;
+
+    if (getEGLThreadInfo()->currentContext == context) {
+        getEGLThreadInfo()->currentContext->deletePending = 1;
+        return EGL_TRUE;
     }
 
     if (context->rcContext) {
@@ -934,12 +955,21 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
     // Nothing to do if no binding change has made
     //
     EGLThreadInfo *tInfo = getEGLThreadInfo();
+
     if (tInfo->currentContext == context &&
         (context == NULL ||
         (context && context->draw == draw && context->read == read))) {
         return EGL_TRUE;
     }
 
+    if (tInfo->currentContext && tInfo->currentContext->deletePending) {
+        if (tInfo->currentContext != context) {
+            EGLContext_t * contextToDelete = tInfo->currentContext;
+            tInfo->currentContext = 0;
+            eglDestroyContext(dpy, contextToDelete);
+        }
+    }
+
     if (context && (context->flags & EGLContext_t::IS_CURRENT) && (context != tInfo->currentContext)) {
         //context is current to another thread
         setErrorReturn(EGL_BAD_ACCESS, EGL_FALSE);
@@ -966,7 +996,7 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
             hostCon->glEncoder()->setSharedGroup(context->getSharedGroup());
         }
     } 
-    else {
+    else if (tInfo->currentContext) {
         //release ClientState & SharedGroup
         if (tInfo->currentContext->version == 2) {
             hostCon->gl2Encoder()->setClientState(NULL);
@@ -1088,6 +1118,7 @@ EGLBoolean eglWaitGL()
 
 EGLBoolean eglWaitNative(EGLint engine)
 {
+    (void)engine;
     return EGL_TRUE;
 }
 
@@ -1113,23 +1144,33 @@ EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface eglSurface)
 EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
 {
     //TODO :later
+    (void)dpy;
+    (void)surface;
+    (void)target;
     return 0;
 }
 
 EGLBoolean eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list)
 {
     //TODO later
+    (void)display;
+    (void)surface;
+    (void)attrib_list;
     return 0;
 }
 
 EGLBoolean eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface)
 {
     //TODO later
+    (void)display;
+    (void)surface;
     return 0;
 }
 
 EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list)
 {
+    (void)attrib_list;
+
     VALIDATE_DISPLAY_INIT(dpy, EGL_NO_IMAGE_KHR);
     if (ctx != EGL_NO_CONTEXT) {
         setErrorReturn(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
@@ -1212,6 +1253,8 @@ EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type,
 
 EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
 {
+    (void)dpy;
+
     if (sync != FENCE_SYNC_HANDLE) {
         setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
     }
@@ -1222,6 +1265,10 @@ EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync)
 EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags,
         EGLTimeKHR timeout)
 {
+    (void)dpy;
+    (void)flags;
+    (void)timeout;
+
     if (sync != FENCE_SYNC_HANDLE) {
         setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
     }
@@ -1232,6 +1279,8 @@ EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags,
 EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync,
         EGLint attribute, EGLint *value)
 {
+    (void)dpy;
+
     if (sync != FENCE_SYNC_HANDLE) {
         setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
     }
diff --git a/opengl/system/egl/eglContext.h b/opengl/system/egl/eglContext.h
index 2ca6d0c..16a2780 100644
--- a/opengl/system/egl/eglContext.h
+++ b/opengl/system/egl/eglContext.h
@@ -40,7 +40,7 @@ struct EGLContext_t {
     const char*         vendorString;
     const char*         rendererString;
     const char*         extensionString;
-
+    EGLint              deletePending;
     GLClientState * getClientState(){ return clientState; }
     GLSharedGroupPtr getSharedGroup(){ return sharedGroup; }
 private:
diff --git a/opengl/system/gralloc/gralloc.cpp b/opengl/system/gralloc/gralloc.cpp
index ac812c1..a6f7d91 100644
--- a/opengl/system/gralloc/gralloc.cpp
+++ b/opengl/system/gralloc/gralloc.cpp
@@ -427,6 +427,8 @@ static int gralloc_device_close(struct hw_device_t *dev)
 
 static int fb_compositionComplete(struct framebuffer_device_t* dev)
 {
+    (void)dev;
+
     return 0;
 }
 
@@ -465,6 +467,11 @@ static int fb_setUpdateRect(struct framebuffer_device_t* dev,
 {
     fb_device_t *fbdev = (fb_device_t *)dev;
 
+    (void)l;
+    (void)t;
+    (void)w;
+    (void)h;
+
     if (!fbdev) {
         return -EINVAL;
     }
diff --git a/opengl/system/renderControl_enc/renderControl_client_context.cpp b/opengl/system/renderControl_enc/renderControl_client_context.cpp
index a4bdb25..f58f549 100644
--- a/opengl/system/renderControl_enc/renderControl_client_context.cpp
+++ b/opengl/system/renderControl_enc/renderControl_client_context.cpp
@@ -10,34 +10,32 @@
 
 int renderControl_client_context_t::initDispatchByName(void *(*getProc)(const char *, void *userData), void *userData)
 {
-	void *ptr;
-
-	ptr = getProc("rcGetRendererVersion", userData); set_rcGetRendererVersion((rcGetRendererVersion_client_proc_t)ptr);
-	ptr = getProc("rcGetEGLVersion", userData); set_rcGetEGLVersion((rcGetEGLVersion_client_proc_t)ptr);
-	ptr = getProc("rcQueryEGLString", userData); set_rcQueryEGLString((rcQueryEGLString_client_proc_t)ptr);
-	ptr = getProc("rcGetGLString", userData); set_rcGetGLString((rcGetGLString_client_proc_t)ptr);
-	ptr = getProc("rcGetNumConfigs", userData); set_rcGetNumConfigs((rcGetNumConfigs_client_proc_t)ptr);
-	ptr = getProc("rcGetConfigs", userData); set_rcGetConfigs((rcGetConfigs_client_proc_t)ptr);
-	ptr = getProc("rcChooseConfig", userData); set_rcChooseConfig((rcChooseConfig_client_proc_t)ptr);
-	ptr = getProc("rcGetFBParam", userData); set_rcGetFBParam((rcGetFBParam_client_proc_t)ptr);
-	ptr = getProc("rcCreateContext", userData); set_rcCreateContext((rcCreateContext_client_proc_t)ptr);
-	ptr = getProc("rcDestroyContext", userData); set_rcDestroyContext((rcDestroyContext_client_proc_t)ptr);
-	ptr = getProc("rcCreateWindowSurface", userData); set_rcCreateWindowSurface((rcCreateWindowSurface_client_proc_t)ptr);
-	ptr = getProc("rcDestroyWindowSurface", userData); set_rcDestroyWindowSurface((rcDestroyWindowSurface_client_proc_t)ptr);
-	ptr = getProc("rcCreateColorBuffer", userData); set_rcCreateColorBuffer((rcCreateColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcOpenColorBuffer", userData); set_rcOpenColorBuffer((rcOpenColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcCloseColorBuffer", userData); set_rcCloseColorBuffer((rcCloseColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcSetWindowColorBuffer", userData); set_rcSetWindowColorBuffer((rcSetWindowColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcFlushWindowColorBuffer", userData); set_rcFlushWindowColorBuffer((rcFlushWindowColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcMakeCurrent", userData); set_rcMakeCurrent((rcMakeCurrent_client_proc_t)ptr);
-	ptr = getProc("rcFBPost", userData); set_rcFBPost((rcFBPost_client_proc_t)ptr);
-	ptr = getProc("rcFBSetSwapInterval", userData); set_rcFBSetSwapInterval((rcFBSetSwapInterval_client_proc_t)ptr);
-	ptr = getProc("rcBindTexture", userData); set_rcBindTexture((rcBindTexture_client_proc_t)ptr);
-	ptr = getProc("rcBindRenderbuffer", userData); set_rcBindRenderbuffer((rcBindRenderbuffer_client_proc_t)ptr);
-	ptr = getProc("rcColorBufferCacheFlush", userData); set_rcColorBufferCacheFlush((rcColorBufferCacheFlush_client_proc_t)ptr);
-	ptr = getProc("rcReadColorBuffer", userData); set_rcReadColorBuffer((rcReadColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcUpdateColorBuffer", userData); set_rcUpdateColorBuffer((rcUpdateColorBuffer_client_proc_t)ptr);
-	ptr = getProc("rcOpenColorBuffer2", userData); set_rcOpenColorBuffer2((rcOpenColorBuffer2_client_proc_t)ptr);
+	rcGetRendererVersion = (rcGetRendererVersion_client_proc_t) getProc("rcGetRendererVersion", userData);
+	rcGetEGLVersion = (rcGetEGLVersion_client_proc_t) getProc("rcGetEGLVersion", userData);
+	rcQueryEGLString = (rcQueryEGLString_client_proc_t) getProc("rcQueryEGLString", userData);
+	rcGetGLString = (rcGetGLString_client_proc_t) getProc("rcGetGLString", userData);
+	rcGetNumConfigs = (rcGetNumConfigs_client_proc_t) getProc("rcGetNumConfigs", userData);
+	rcGetConfigs = (rcGetConfigs_client_proc_t) getProc("rcGetConfigs", userData);
+	rcChooseConfig = (rcChooseConfig_client_proc_t) getProc("rcChooseConfig", userData);
+	rcGetFBParam = (rcGetFBParam_client_proc_t) getProc("rcGetFBParam", userData);
+	rcCreateContext = (rcCreateContext_client_proc_t) getProc("rcCreateContext", userData);
+	rcDestroyContext = (rcDestroyContext_client_proc_t) getProc("rcDestroyContext", userData);
+	rcCreateWindowSurface = (rcCreateWindowSurface_client_proc_t) getProc("rcCreateWindowSurface", userData);
+	rcDestroyWindowSurface = (rcDestroyWindowSurface_client_proc_t) getProc("rcDestroyWindowSurface", userData);
+	rcCreateColorBuffer = (rcCreateColorBuffer_client_proc_t) getProc("rcCreateColorBuffer", userData);
+	rcOpenColorBuffer = (rcOpenColorBuffer_client_proc_t) getProc("rcOpenColorBuffer", userData);
+	rcCloseColorBuffer = (rcCloseColorBuffer_client_proc_t) getProc("rcCloseColorBuffer", userData);
+	rcSetWindowColorBuffer = (rcSetWindowColorBuffer_client_proc_t) getProc("rcSetWindowColorBuffer", userData);
+	rcFlushWindowColorBuffer = (rcFlushWindowColorBuffer_client_proc_t) getProc("rcFlushWindowColorBuffer", userData);
+	rcMakeCurrent = (rcMakeCurrent_client_proc_t) getProc("rcMakeCurrent", userData);
+	rcFBPost = (rcFBPost_client_proc_t) getProc("rcFBPost", userData);
+	rcFBSetSwapInterval = (rcFBSetSwapInterval_client_proc_t) getProc("rcFBSetSwapInterval", userData);
+	rcBindTexture = (rcBindTexture_client_proc_t) getProc("rcBindTexture", userData);
+	rcBindRenderbuffer = (rcBindRenderbuffer_client_proc_t) getProc("rcBindRenderbuffer", userData);
+	rcColorBufferCacheFlush = (rcColorBufferCacheFlush_client_proc_t) getProc("rcColorBufferCacheFlush", userData);
+	rcReadColorBuffer = (rcReadColorBuffer_client_proc_t) getProc("rcReadColorBuffer", userData);
+	rcUpdateColorBuffer = (rcUpdateColorBuffer_client_proc_t) getProc("rcUpdateColorBuffer", userData);
+	rcOpenColorBuffer2 = (rcOpenColorBuffer2_client_proc_t) getProc("rcOpenColorBuffer2", userData);
 	return 0;
 }
 
diff --git a/opengl/system/renderControl_enc/renderControl_client_context.h b/opengl/system/renderControl_enc/renderControl_client_context.h
index 46a007f..4c71d89 100644
--- a/opengl/system/renderControl_enc/renderControl_client_context.h
+++ b/opengl/system/renderControl_enc/renderControl_client_context.h
@@ -34,39 +34,12 @@ struct renderControl_client_context_t {
 	rcReadColorBuffer_client_proc_t rcReadColorBuffer;
 	rcUpdateColorBuffer_client_proc_t rcUpdateColorBuffer;
 	rcOpenColorBuffer2_client_proc_t rcOpenColorBuffer2;
-	//Accessors 
-	virtual rcGetRendererVersion_client_proc_t set_rcGetRendererVersion(rcGetRendererVersion_client_proc_t f) { rcGetRendererVersion_client_proc_t retval = rcGetRendererVersion; rcGetRendererVersion = f; return retval;}
-	virtual rcGetEGLVersion_client_proc_t set_rcGetEGLVersion(rcGetEGLVersion_client_proc_t f) { rcGetEGLVersion_client_proc_t retval = rcGetEGLVersion; rcGetEGLVersion = f; return retval;}
-	virtual rcQueryEGLString_client_proc_t set_rcQueryEGLString(rcQueryEGLString_client_proc_t f) { rcQueryEGLString_client_proc_t retval = rcQueryEGLString; rcQueryEGLString = f; return retval;}
-	virtual rcGetGLString_client_proc_t set_rcGetGLString(rcGetGLString_client_proc_t f) { rcGetGLString_client_proc_t retval = rcGetGLString; rcGetGLString = f; return retval;}
-	virtual rcGetNumConfigs_client_proc_t set_rcGetNumConfigs(rcGetNumConfigs_client_proc_t f) { rcGetNumConfigs_client_proc_t retval = rcGetNumConfigs; rcGetNumConfigs = f; return retval;}
-	virtual rcGetConfigs_client_proc_t set_rcGetConfigs(rcGetConfigs_client_proc_t f) { rcGetConfigs_client_proc_t retval = rcGetConfigs; rcGetConfigs = f; return retval;}
-	virtual rcChooseConfig_client_proc_t set_rcChooseConfig(rcChooseConfig_client_proc_t f) { rcChooseConfig_client_proc_t retval = rcChooseConfig; rcChooseConfig = f; return retval;}
-	virtual rcGetFBParam_client_proc_t set_rcGetFBParam(rcGetFBParam_client_proc_t f) { rcGetFBParam_client_proc_t retval = rcGetFBParam; rcGetFBParam = f; return retval;}
-	virtual rcCreateContext_client_proc_t set_rcCreateContext(rcCreateContext_client_proc_t f) { rcCreateContext_client_proc_t retval = rcCreateContext; rcCreateContext = f; return retval;}
-	virtual rcDestroyContext_client_proc_t set_rcDestroyContext(rcDestroyContext_client_proc_t f) { rcDestroyContext_client_proc_t retval = rcDestroyContext; rcDestroyContext = f; return retval;}
-	virtual rcCreateWindowSurface_client_proc_t set_rcCreateWindowSurface(rcCreateWindowSurface_client_proc_t f) { rcCreateWindowSurface_client_proc_t retval = rcCreateWindowSurface; rcCreateWindowSurface = f; return retval;}
-	virtual rcDestroyWindowSurface_client_proc_t set_rcDestroyWindowSurface(rcDestroyWindowSurface_client_proc_t f) { rcDestroyWindowSurface_client_proc_t retval = rcDestroyWindowSurface; rcDestroyWindowSurface = f; return retval;}
-	virtual rcCreateColorBuffer_client_proc_t set_rcCreateColorBuffer(rcCreateColorBuffer_client_proc_t f) { rcCreateColorBuffer_client_proc_t retval = rcCreateColorBuffer; rcCreateColorBuffer = f; return retval;}
-	virtual rcOpenColorBuffer_client_proc_t set_rcOpenColorBuffer(rcOpenColorBuffer_client_proc_t f) { rcOpenColorBuffer_client_proc_t retval = rcOpenColorBuffer; rcOpenColorBuffer = f; return retval;}
-	virtual rcCloseColorBuffer_client_proc_t set_rcCloseColorBuffer(rcCloseColorBuffer_client_proc_t f) { rcCloseColorBuffer_client_proc_t retval = rcCloseColorBuffer; rcCloseColorBuffer = f; return retval;}
-	virtual rcSetWindowColorBuffer_client_proc_t set_rcSetWindowColorBuffer(rcSetWindowColorBuffer_client_proc_t f) { rcSetWindowColorBuffer_client_proc_t retval = rcSetWindowColorBuffer; rcSetWindowColorBuffer = f; return retval;}
-	virtual rcFlushWindowColorBuffer_client_proc_t set_rcFlushWindowColorBuffer(rcFlushWindowColorBuffer_client_proc_t f) { rcFlushWindowColorBuffer_client_proc_t retval = rcFlushWindowColorBuffer; rcFlushWindowColorBuffer = f; return retval;}
-	virtual rcMakeCurrent_client_proc_t set_rcMakeCurrent(rcMakeCurrent_client_proc_t f) { rcMakeCurrent_client_proc_t retval = rcMakeCurrent; rcMakeCurrent = f; return retval;}
-	virtual rcFBPost_client_proc_t set_rcFBPost(rcFBPost_client_proc_t f) { rcFBPost_client_proc_t retval = rcFBPost; rcFBPost = f; return retval;}
-	virtual rcFBSetSwapInterval_client_proc_t set_rcFBSetSwapInterval(rcFBSetSwapInterval_client_proc_t f) { rcFBSetSwapInterval_client_proc_t retval = rcFBSetSwapInterval; rcFBSetSwapInterval = f; return retval;}
-	virtual rcBindTexture_client_proc_t set_rcBindTexture(rcBindTexture_client_proc_t f) { rcBindTexture_client_proc_t retval = rcBindTexture; rcBindTexture = f; return retval;}
-	virtual rcBindRenderbuffer_client_proc_t set_rcBindRenderbuffer(rcBindRenderbuffer_client_proc_t f) { rcBindRenderbuffer_client_proc_t retval = rcBindRenderbuffer; rcBindRenderbuffer = f; return retval;}
-	virtual rcColorBufferCacheFlush_client_proc_t set_rcColorBufferCacheFlush(rcColorBufferCacheFlush_client_proc_t f) { rcColorBufferCacheFlush_client_proc_t retval = rcColorBufferCacheFlush; rcColorBufferCacheFlush = f; return retval;}
-	virtual rcReadColorBuffer_client_proc_t set_rcReadColorBuffer(rcReadColorBuffer_client_proc_t f) { rcReadColorBuffer_client_proc_t retval = rcReadColorBuffer; rcReadColorBuffer = f; return retval;}
-	virtual rcUpdateColorBuffer_client_proc_t set_rcUpdateColorBuffer(rcUpdateColorBuffer_client_proc_t f) { rcUpdateColorBuffer_client_proc_t retval = rcUpdateColorBuffer; rcUpdateColorBuffer = f; return retval;}
-	virtual rcOpenColorBuffer2_client_proc_t set_rcOpenColorBuffer2(rcOpenColorBuffer2_client_proc_t f) { rcOpenColorBuffer2_client_proc_t retval = rcOpenColorBuffer2; rcOpenColorBuffer2 = f; return retval;}
 	 virtual ~renderControl_client_context_t() {}
 
 	typedef renderControl_client_context_t *CONTEXT_ACCESSOR_TYPE(void);
 	static void setContextAccessor(CONTEXT_ACCESSOR_TYPE *f);
 	int initDispatchByName( void *(*getProc)(const char *name, void *userData), void *userData);
-	virtual void setError(unsigned int  error){};
+	virtual void setError(unsigned int  error){ (void)error; };
 	virtual unsigned int getError(){ return 0; };
 };
 
diff --git a/opengl/system/renderControl_enc/renderControl_enc.cpp b/opengl/system/renderControl_enc/renderControl_enc.cpp
index a40a501..34113e1 100644
--- a/opengl/system/renderControl_enc/renderControl_enc.cpp
+++ b/opengl/system/renderControl_enc/renderControl_enc.cpp
@@ -9,7 +9,10 @@
 
 
 #include <stdio.h>
-static void enc_unsupported()
+
+namespace {
+
+void enc_unsupported()
 {
 	ALOGE("Function is unsupported\n");
 }
@@ -311,7 +314,6 @@ void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer)
 	memcpy(ptr, &packetSize, 4);  ptr += 4;
 
 		memcpy(ptr, &colorbuffer, 4); ptr += 4;
-
 	stream->flush();
 }
 
@@ -524,35 +526,37 @@ int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer)
 	return retval;
 }
 
+}  // namespace
+
 renderControl_encoder_context_t::renderControl_encoder_context_t(IOStream *stream)
 {
 	m_stream = stream;
 
-	set_rcGetRendererVersion(rcGetRendererVersion_enc);
-	set_rcGetEGLVersion(rcGetEGLVersion_enc);
-	set_rcQueryEGLString(rcQueryEGLString_enc);
-	set_rcGetGLString(rcGetGLString_enc);
-	set_rcGetNumConfigs(rcGetNumConfigs_enc);
-	set_rcGetConfigs(rcGetConfigs_enc);
-	set_rcChooseConfig(rcChooseConfig_enc);
-	set_rcGetFBParam(rcGetFBParam_enc);
-	set_rcCreateContext(rcCreateContext_enc);
-	set_rcDestroyContext(rcDestroyContext_enc);
-	set_rcCreateWindowSurface(rcCreateWindowSurface_enc);
-	set_rcDestroyWindowSurface(rcDestroyWindowSurface_enc);
-	set_rcCreateColorBuffer(rcCreateColorBuffer_enc);
-	set_rcOpenColorBuffer(rcOpenColorBuffer_enc);
-	set_rcCloseColorBuffer(rcCloseColorBuffer_enc);
-	set_rcSetWindowColorBuffer(rcSetWindowColorBuffer_enc);
-	set_rcFlushWindowColorBuffer(rcFlushWindowColorBuffer_enc);
-	set_rcMakeCurrent(rcMakeCurrent_enc);
-	set_rcFBPost(rcFBPost_enc);
-	set_rcFBSetSwapInterval(rcFBSetSwapInterval_enc);
-	set_rcBindTexture(rcBindTexture_enc);
-	set_rcBindRenderbuffer(rcBindRenderbuffer_enc);
-	set_rcColorBufferCacheFlush(rcColorBufferCacheFlush_enc);
-	set_rcReadColorBuffer(rcReadColorBuffer_enc);
-	set_rcUpdateColorBuffer(rcUpdateColorBuffer_enc);
-	set_rcOpenColorBuffer2(rcOpenColorBuffer2_enc);
+	this->rcGetRendererVersion = &rcGetRendererVersion_enc;
+	this->rcGetEGLVersion = &rcGetEGLVersion_enc;
+	this->rcQueryEGLString = &rcQueryEGLString_enc;
+	this->rcGetGLString = &rcGetGLString_enc;
+	this->rcGetNumConfigs = &rcGetNumConfigs_enc;
+	this->rcGetConfigs = &rcGetConfigs_enc;
+	this->rcChooseConfig = &rcChooseConfig_enc;
+	this->rcGetFBParam = &rcGetFBParam_enc;
+	this->rcCreateContext = &rcCreateContext_enc;
+	this->rcDestroyContext = &rcDestroyContext_enc;
+	this->rcCreateWindowSurface = &rcCreateWindowSurface_enc;
+	this->rcDestroyWindowSurface = &rcDestroyWindowSurface_enc;
+	this->rcCreateColorBuffer = &rcCreateColorBuffer_enc;
+	this->rcOpenColorBuffer = &rcOpenColorBuffer_enc;
+	this->rcCloseColorBuffer = &rcCloseColorBuffer_enc;
+	this->rcSetWindowColorBuffer = &rcSetWindowColorBuffer_enc;
+	this->rcFlushWindowColorBuffer = &rcFlushWindowColorBuffer_enc;
+	this->rcMakeCurrent = &rcMakeCurrent_enc;
+	this->rcFBPost = &rcFBPost_enc;
+	this->rcFBSetSwapInterval = &rcFBSetSwapInterval_enc;
+	this->rcBindTexture = &rcBindTexture_enc;
+	this->rcBindRenderbuffer = &rcBindRenderbuffer_enc;
+	this->rcColorBufferCacheFlush = &rcColorBufferCacheFlush_enc;
+	this->rcReadColorBuffer = &rcReadColorBuffer_enc;
+	this->rcUpdateColorBuffer = &rcUpdateColorBuffer_enc;
+	this->rcOpenColorBuffer2 = &rcOpenColorBuffer2_enc;
 }
 
diff --git a/opengl/system/renderControl_enc/renderControl_enc.h b/opengl/system/renderControl_enc/renderControl_enc.h
index 92ef76e..9469ae4 100644
--- a/opengl/system/renderControl_enc/renderControl_enc.h
+++ b/opengl/system/renderControl_enc/renderControl_enc.h
@@ -17,36 +17,6 @@ struct renderControl_encoder_context_t : public renderControl_client_context_t {
 	IOStream *m_stream;
 
 	renderControl_encoder_context_t(IOStream *stream);
-
-
 };
 
-extern "C" {
-	GLint rcGetRendererVersion_enc(void *self );
-	EGLint rcGetEGLVersion_enc(void *self , EGLint* major, EGLint* minor);
-	EGLint rcQueryEGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize);
-	EGLint rcGetGLString_enc(void *self , EGLenum name, void* buffer, EGLint bufferSize);
-	EGLint rcGetNumConfigs_enc(void *self , uint32_t* numAttribs);
-	EGLint rcGetConfigs_enc(void *self , uint32_t bufSize, GLuint* buffer);
-	EGLint rcChooseConfig_enc(void *self , EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size);
-	EGLint rcGetFBParam_enc(void *self , EGLint param);
-	uint32_t rcCreateContext_enc(void *self , uint32_t config, uint32_t share, uint32_t glVersion);
-	void rcDestroyContext_enc(void *self , uint32_t context);
-	uint32_t rcCreateWindowSurface_enc(void *self , uint32_t config, uint32_t width, uint32_t height);
-	void rcDestroyWindowSurface_enc(void *self , uint32_t windowSurface);
-	uint32_t rcCreateColorBuffer_enc(void *self , uint32_t width, uint32_t height, GLenum internalFormat);
-	void rcOpenColorBuffer_enc(void *self , uint32_t colorbuffer);
-	void rcCloseColorBuffer_enc(void *self , uint32_t colorbuffer);
-	void rcSetWindowColorBuffer_enc(void *self , uint32_t windowSurface, uint32_t colorBuffer);
-	int rcFlushWindowColorBuffer_enc(void *self , uint32_t windowSurface);
-	EGLint rcMakeCurrent_enc(void *self , uint32_t context, uint32_t drawSurf, uint32_t readSurf);
-	void rcFBPost_enc(void *self , uint32_t colorBuffer);
-	void rcFBSetSwapInterval_enc(void *self , EGLint interval);
-	void rcBindTexture_enc(void *self , uint32_t colorBuffer);
-	void rcBindRenderbuffer_enc(void *self , uint32_t colorBuffer);
-	EGLint rcColorBufferCacheFlush_enc(void *self , uint32_t colorbuffer, EGLint postCount, int forRead);
-	void rcReadColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels);
-	int rcUpdateColorBuffer_enc(void *self , uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels);
-	int rcOpenColorBuffer2_enc(void *self , uint32_t colorbuffer);
-};
-#endif
\ No newline at end of file
+#endif  // GUARD_renderControl_encoder_context_t
\ No newline at end of file
diff --git a/opengl/system/renderControl_enc/renderControl_entry.cpp b/opengl/system/renderControl_enc/renderControl_entry.cpp
index a15fd14..71edb83 100644
--- a/opengl/system/renderControl_enc/renderControl_entry.cpp
+++ b/opengl/system/renderControl_enc/renderControl_entry.cpp
@@ -38,162 +38,162 @@ extern "C" {
 #ifndef GET_CONTEXT
 static renderControl_client_context_t::CONTEXT_ACCESSOR_TYPE *getCurrentContext = NULL;
 void renderControl_client_context_t::setContextAccessor(CONTEXT_ACCESSOR_TYPE *f) { getCurrentContext = f; }
-#define GET_CONTEXT renderControl_client_context_t * ctx = getCurrentContext() 
+#define GET_CONTEXT renderControl_client_context_t * ctx = getCurrentContext()
 #endif
 
 GLint rcGetRendererVersion()
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetRendererVersion(ctx);
+	GET_CONTEXT;
+	return ctx->rcGetRendererVersion(ctx);
 }
 
 EGLint rcGetEGLVersion(EGLint* major, EGLint* minor)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetEGLVersion(ctx, major, minor);
+	GET_CONTEXT;
+	return ctx->rcGetEGLVersion(ctx, major, minor);
 }
 
 EGLint rcQueryEGLString(EGLenum name, void* buffer, EGLint bufferSize)
 {
-	GET_CONTEXT; 
-	 return ctx->rcQueryEGLString(ctx, name, buffer, bufferSize);
+	GET_CONTEXT;
+	return ctx->rcQueryEGLString(ctx, name, buffer, bufferSize);
 }
 
 EGLint rcGetGLString(EGLenum name, void* buffer, EGLint bufferSize)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetGLString(ctx, name, buffer, bufferSize);
+	GET_CONTEXT;
+	return ctx->rcGetGLString(ctx, name, buffer, bufferSize);
 }
 
 EGLint rcGetNumConfigs(uint32_t* numAttribs)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetNumConfigs(ctx, numAttribs);
+	GET_CONTEXT;
+	return ctx->rcGetNumConfigs(ctx, numAttribs);
 }
 
 EGLint rcGetConfigs(uint32_t bufSize, GLuint* buffer)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetConfigs(ctx, bufSize, buffer);
+	GET_CONTEXT;
+	return ctx->rcGetConfigs(ctx, bufSize, buffer);
 }
 
 EGLint rcChooseConfig(EGLint* attribs, uint32_t attribs_size, uint32_t* configs, uint32_t configs_size)
 {
-	GET_CONTEXT; 
-	 return ctx->rcChooseConfig(ctx, attribs, attribs_size, configs, configs_size);
+	GET_CONTEXT;
+	return ctx->rcChooseConfig(ctx, attribs, attribs_size, configs, configs_size);
 }
 
 EGLint rcGetFBParam(EGLint param)
 {
-	GET_CONTEXT; 
-	 return ctx->rcGetFBParam(ctx, param);
+	GET_CONTEXT;
+	return ctx->rcGetFBParam(ctx, param);
 }
 
 uint32_t rcCreateContext(uint32_t config, uint32_t share, uint32_t glVersion)
 {
-	GET_CONTEXT; 
-	 return ctx->rcCreateContext(ctx, config, share, glVersion);
+	GET_CONTEXT;
+	return ctx->rcCreateContext(ctx, config, share, glVersion);
 }
 
 void rcDestroyContext(uint32_t context)
 {
-	GET_CONTEXT; 
-	 ctx->rcDestroyContext(ctx, context);
+	GET_CONTEXT;
+	ctx->rcDestroyContext(ctx, context);
 }
 
 uint32_t rcCreateWindowSurface(uint32_t config, uint32_t width, uint32_t height)
 {
-	GET_CONTEXT; 
-	 return ctx->rcCreateWindowSurface(ctx, config, width, height);
+	GET_CONTEXT;
+	return ctx->rcCreateWindowSurface(ctx, config, width, height);
 }
 
 void rcDestroyWindowSurface(uint32_t windowSurface)
 {
-	GET_CONTEXT; 
-	 ctx->rcDestroyWindowSurface(ctx, windowSurface);
+	GET_CONTEXT;
+	ctx->rcDestroyWindowSurface(ctx, windowSurface);
 }
 
 uint32_t rcCreateColorBuffer(uint32_t width, uint32_t height, GLenum internalFormat)
 {
-	GET_CONTEXT; 
-	 return ctx->rcCreateColorBuffer(ctx, width, height, internalFormat);
+	GET_CONTEXT;
+	return ctx->rcCreateColorBuffer(ctx, width, height, internalFormat);
 }
 
 void rcOpenColorBuffer(uint32_t colorbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcOpenColorBuffer(ctx, colorbuffer);
+	GET_CONTEXT;
+	ctx->rcOpenColorBuffer(ctx, colorbuffer);
 }
 
 void rcCloseColorBuffer(uint32_t colorbuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcCloseColorBuffer(ctx, colorbuffer);
+	GET_CONTEXT;
+	ctx->rcCloseColorBuffer(ctx, colorbuffer);
 }
 
 void rcSetWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcSetWindowColorBuffer(ctx, windowSurface, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcSetWindowColorBuffer(ctx, windowSurface, colorBuffer);
 }
 
 int rcFlushWindowColorBuffer(uint32_t windowSurface)
 {
-	GET_CONTEXT; 
-	 return ctx->rcFlushWindowColorBuffer(ctx, windowSurface);
+	GET_CONTEXT;
+	return ctx->rcFlushWindowColorBuffer(ctx, windowSurface);
 }
 
 EGLint rcMakeCurrent(uint32_t context, uint32_t drawSurf, uint32_t readSurf)
 {
-	GET_CONTEXT; 
-	 return ctx->rcMakeCurrent(ctx, context, drawSurf, readSurf);
+	GET_CONTEXT;
+	return ctx->rcMakeCurrent(ctx, context, drawSurf, readSurf);
 }
 
 void rcFBPost(uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcFBPost(ctx, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcFBPost(ctx, colorBuffer);
 }
 
 void rcFBSetSwapInterval(EGLint interval)
 {
-	GET_CONTEXT; 
-	 ctx->rcFBSetSwapInterval(ctx, interval);
+	GET_CONTEXT;
+	ctx->rcFBSetSwapInterval(ctx, interval);
 }
 
 void rcBindTexture(uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcBindTexture(ctx, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcBindTexture(ctx, colorBuffer);
 }
 
 void rcBindRenderbuffer(uint32_t colorBuffer)
 {
-	GET_CONTEXT; 
-	 ctx->rcBindRenderbuffer(ctx, colorBuffer);
+	GET_CONTEXT;
+	ctx->rcBindRenderbuffer(ctx, colorBuffer);
 }
 
 EGLint rcColorBufferCacheFlush(uint32_t colorbuffer, EGLint postCount, int forRead)
 {
-	GET_CONTEXT; 
-	 return ctx->rcColorBufferCacheFlush(ctx, colorbuffer, postCount, forRead);
+	GET_CONTEXT;
+	return ctx->rcColorBufferCacheFlush(ctx, colorbuffer, postCount, forRead);
 }
 
 void rcReadColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
 {
-	GET_CONTEXT; 
-	 ctx->rcReadColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
+	GET_CONTEXT;
+	ctx->rcReadColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
 }
 
 int rcUpdateColorBuffer(uint32_t colorbuffer, GLint x, GLint y, GLint width, GLint height, GLenum format, GLenum type, void* pixels)
 {
-	GET_CONTEXT; 
-	 return ctx->rcUpdateColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
+	GET_CONTEXT;
+	return ctx->rcUpdateColorBuffer(ctx, colorbuffer, x, y, width, height, format, type, pixels);
 }
 
 int rcOpenColorBuffer2(uint32_t colorbuffer)
 {
-	GET_CONTEXT; 
-	 return ctx->rcOpenColorBuffer2(ctx, colorbuffer);
+	GET_CONTEXT;
+	return ctx->rcOpenColorBuffer2(ctx, colorbuffer);
 }
 
diff --git a/opengl/system/renderControl_enc/renderControl_ftable.h b/opengl/system/renderControl_enc/renderControl_ftable.h
index a43fe5b..e15fb0c 100644
--- a/opengl/system/renderControl_enc/renderControl_ftable.h
+++ b/opengl/system/renderControl_enc/renderControl_ftable.h
@@ -4,7 +4,7 @@
 #define __renderControl_client_ftable_t_h
 
 
-static struct _renderControl_funcs_by_name {
+static const struct _renderControl_funcs_by_name {
 	const char *name;
 	void *proc;
 } renderControl_funcs_by_name[] = {
@@ -35,7 +35,7 @@ static struct _renderControl_funcs_by_name {
 	{"rcUpdateColorBuffer", (void*)rcUpdateColorBuffer},
 	{"rcOpenColorBuffer2", (void*)rcOpenColorBuffer2},
 };
-static int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
+static const int renderControl_num_funcs = sizeof(renderControl_funcs_by_name) / sizeof(struct _renderControl_funcs_by_name);
 
 
 #endif