Make QGLFunctions wrap QOpenGLFunctions

Remove the duplicated implementation.

When moving to support also dynamic GL builds, having a standalone
QGLFunctions is not feasible anymore since the changes made to
QOpenGLFunctions will not be backported to QGLFunctions.

Change-Id: Iaf742e496d3c92d6d915baee93283180259e27a6
Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>

2 files changed, 115 insertions, 3067 deletions

diff --git a/src/opengl/qglfunctions.cpp b/src/opengl/qglfunctions.cpp
index 7dc30d5319..d82e55eba1 100644
--- a/src/opengl/qglfunctions.cpp
+++ b/src/opengl/qglfunctions.cpp
@@ -150,7 +150,16 @@ struct QGLFunctionsPrivateEx : public QGLFunctionsPrivate, public QOpenGLSharedR
     QGLFunctionsPrivateEx(QOpenGLContext *context)
         : QGLFunctionsPrivate(QGLContext::fromOpenGLContext(context))
         , QOpenGLSharedResource(context->shareGroup())
-        , m_features(-1) {}
+        , m_features(-1)
+    {
+        funcs = new QOpenGLFunctions(context);
+        funcs->initializeOpenGLFunctions();
+    }
+
+    ~QGLFunctionsPrivateEx()
+    {
+        delete funcs;
+    }
 
     void invalidateResource()
     {
@@ -1363,2360 +1372,9 @@ void QGLFunctions::initializeGLFunctions(const QGLContext *context)
     This convenience function will do nothing on OpenGL/ES 1.x systems.
 */
 
-#ifndef QT_OPENGL_ES_2
-
-static void QGLF_APIENTRY qglfResolveActiveTexture(GLenum texture)
-{
-    typedef void (QGLF_APIENTRYP type_glActiveTexture)(GLenum texture);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->activeTexture = (type_glActiveTexture)
-        context->getProcAddress(QLatin1String("glActiveTexture"));
-    if (!funcs->activeTexture) {
-        funcs->activeTexture = (type_glActiveTexture)
-            context->getProcAddress(QLatin1String("glActiveTextureARB"));
-    }
-
-    if (funcs->activeTexture)
-        funcs->activeTexture(texture);
-    else
-        funcs->activeTexture = qglfResolveActiveTexture;
-}
-
-static void QGLF_APIENTRY qglfResolveAttachShader(GLuint program, GLuint shader)
-{
-    typedef void (QGLF_APIENTRYP type_glAttachShader)(GLuint program, GLuint shader);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->attachShader = (type_glAttachShader)
-        context->getProcAddress(QLatin1String("glAttachShader"));
-    if (!funcs->attachShader) {
-        funcs->attachShader = (type_glAttachShader)
-            context->getProcAddress(QLatin1String("glAttachObjectARB"));
-    }
-
-    if (funcs->attachShader)
-        funcs->attachShader(program, shader);
-    else
-        funcs->attachShader = qglfResolveAttachShader;
-}
-
-static void QGLF_APIENTRY qglfResolveBindAttribLocation(GLuint program, GLuint index, const char* name)
-{
-    typedef void (QGLF_APIENTRYP type_glBindAttribLocation)(GLuint program, GLuint index, const char* name);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->bindAttribLocation = (type_glBindAttribLocation)
-        context->getProcAddress(QLatin1String("glBindAttribLocation"));
-    if (!funcs->bindAttribLocation) {
-        funcs->bindAttribLocation = (type_glBindAttribLocation)
-            context->getProcAddress(QLatin1String("glBindAttribLocationARB"));
-    }
-
-    if (funcs->bindAttribLocation)
-        funcs->bindAttribLocation(program, index, name);
-    else
-        funcs->bindAttribLocation = qglfResolveBindAttribLocation;
-}
-
-static void QGLF_APIENTRY qglfResolveBindBuffer(GLenum target, GLuint buffer)
-{
-    typedef void (QGLF_APIENTRYP type_glBindBuffer)(GLenum target, GLuint buffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->bindBuffer = (type_glBindBuffer)
-        context->getProcAddress(QLatin1String("glBindBuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->bindBuffer) {
-        funcs->bindBuffer = (type_glBindBuffer)
-            context->getProcAddress(QLatin1String("glBindBufferOES"));
-    }
-#endif
-    if (!funcs->bindBuffer) {
-        funcs->bindBuffer = (type_glBindBuffer)
-            context->getProcAddress(QLatin1String("glBindBufferEXT"));
-    }
-    if (!funcs->bindBuffer) {
-        funcs->bindBuffer = (type_glBindBuffer)
-            context->getProcAddress(QLatin1String("glBindBufferARB"));
-    }
-
-    if (funcs->bindBuffer)
-        funcs->bindBuffer(target, buffer);
-    else
-        funcs->bindBuffer = qglfResolveBindBuffer;
-}
-
-static void QGLF_APIENTRY qglfResolveBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    typedef void (QGLF_APIENTRYP type_glBindFramebuffer)(GLenum target, GLuint framebuffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->bindFramebuffer = (type_glBindFramebuffer)
-        context->getProcAddress(QLatin1String("glBindFramebuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->bindFramebuffer) {
-        funcs->bindFramebuffer = (type_glBindFramebuffer)
-            context->getProcAddress(QLatin1String("glBindFramebufferOES"));
-    }
-#endif
-    if (!funcs->bindFramebuffer) {
-        funcs->bindFramebuffer = (type_glBindFramebuffer)
-            context->getProcAddress(QLatin1String("glBindFramebufferEXT"));
-    }
-    if (!funcs->bindFramebuffer) {
-        funcs->bindFramebuffer = (type_glBindFramebuffer)
-            context->getProcAddress(QLatin1String("glBindFramebufferARB"));
-    }
-
-    if (funcs->bindFramebuffer)
-        funcs->bindFramebuffer(target, framebuffer);
-    else
-        funcs->bindFramebuffer = qglfResolveBindFramebuffer;
-}
-
-static void QGLF_APIENTRY qglfResolveBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    typedef void (QGLF_APIENTRYP type_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->bindRenderbuffer = (type_glBindRenderbuffer)
-        context->getProcAddress(QLatin1String("glBindRenderbuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->bindRenderbuffer) {
-        funcs->bindRenderbuffer = (type_glBindRenderbuffer)
-            context->getProcAddress(QLatin1String("glBindRenderbufferOES"));
-    }
-#endif
-    if (!funcs->bindRenderbuffer) {
-        funcs->bindRenderbuffer = (type_glBindRenderbuffer)
-            context->getProcAddress(QLatin1String("glBindRenderbufferEXT"));
-    }
-    if (!funcs->bindRenderbuffer) {
-        funcs->bindRenderbuffer = (type_glBindRenderbuffer)
-            context->getProcAddress(QLatin1String("glBindRenderbufferARB"));
-    }
-
-    if (funcs->bindRenderbuffer)
-        funcs->bindRenderbuffer(target, renderbuffer);
-    else
-        funcs->bindRenderbuffer = qglfResolveBindRenderbuffer;
-}
-
-static void QGLF_APIENTRY qglfResolveBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-    typedef void (QGLF_APIENTRYP type_glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->blendColor = (type_glBlendColor)
-        context->getProcAddress(QLatin1String("glBlendColor"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->blendColor) {
-        funcs->blendColor = (type_glBlendColor)
-            context->getProcAddress(QLatin1String("glBlendColorOES"));
-    }
-#endif
-    if (!funcs->blendColor) {
-        funcs->blendColor = (type_glBlendColor)
-            context->getProcAddress(QLatin1String("glBlendColorEXT"));
-    }
-    if (!funcs->blendColor) {
-        funcs->blendColor = (type_glBlendColor)
-            context->getProcAddress(QLatin1String("glBlendColorARB"));
-    }
-
-    if (funcs->blendColor)
-        funcs->blendColor(red, green, blue, alpha);
-    else
-        funcs->blendColor = qglfResolveBlendColor;
-}
-
-static void QGLF_APIENTRY qglfResolveBlendEquation(GLenum mode)
-{
-    typedef void (QGLF_APIENTRYP type_glBlendEquation)(GLenum mode);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->blendEquation = (type_glBlendEquation)
-        context->getProcAddress(QLatin1String("glBlendEquation"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->blendEquation) {
-        funcs->blendEquation = (type_glBlendEquation)
-            context->getProcAddress(QLatin1String("glBlendEquationOES"));
-    }
-#endif
-    if (!funcs->blendEquation) {
-        funcs->blendEquation = (type_glBlendEquation)
-            context->getProcAddress(QLatin1String("glBlendEquationEXT"));
-    }
-    if (!funcs->blendEquation) {
-        funcs->blendEquation = (type_glBlendEquation)
-            context->getProcAddress(QLatin1String("glBlendEquationARB"));
-    }
-
-    if (funcs->blendEquation)
-        funcs->blendEquation(mode);
-    else
-        funcs->blendEquation = qglfResolveBlendEquation;
-}
-
-static void QGLF_APIENTRY qglfResolveBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    typedef void (QGLF_APIENTRYP type_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
-        context->getProcAddress(QLatin1String("glBlendEquationSeparate"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->blendEquationSeparate) {
-        funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
-            context->getProcAddress(QLatin1String("glBlendEquationSeparateOES"));
-    }
-#endif
-    if (!funcs->blendEquationSeparate) {
-        funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
-            context->getProcAddress(QLatin1String("glBlendEquationSeparateEXT"));
-    }
-    if (!funcs->blendEquationSeparate) {
-        funcs->blendEquationSeparate = (type_glBlendEquationSeparate)
-            context->getProcAddress(QLatin1String("glBlendEquationSeparateARB"));
-    }
-
-    if (funcs->blendEquationSeparate)
-        funcs->blendEquationSeparate(modeRGB, modeAlpha);
-    else
-        funcs->blendEquationSeparate = qglfResolveBlendEquationSeparate;
-}
-
-static void QGLF_APIENTRY qglfResolveBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    typedef void (QGLF_APIENTRYP type_glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
-        context->getProcAddress(QLatin1String("glBlendFuncSeparate"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->blendFuncSeparate) {
-        funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
-            context->getProcAddress(QLatin1String("glBlendFuncSeparateOES"));
-    }
-#endif
-    if (!funcs->blendFuncSeparate) {
-        funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
-            context->getProcAddress(QLatin1String("glBlendFuncSeparateEXT"));
-    }
-    if (!funcs->blendFuncSeparate) {
-        funcs->blendFuncSeparate = (type_glBlendFuncSeparate)
-            context->getProcAddress(QLatin1String("glBlendFuncSeparateARB"));
-    }
-
-    if (funcs->blendFuncSeparate)
-        funcs->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-    else
-        funcs->blendFuncSeparate = qglfResolveBlendFuncSeparate;
-}
-
-static void QGLF_APIENTRY qglfResolveBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage)
-{
-    typedef void (QGLF_APIENTRYP type_glBufferData)(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->bufferData = (type_glBufferData)
-        context->getProcAddress(QLatin1String("glBufferData"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->bufferData) {
-        funcs->bufferData = (type_glBufferData)
-            context->getProcAddress(QLatin1String("glBufferDataOES"));
-    }
-#endif
-    if (!funcs->bufferData) {
-        funcs->bufferData = (type_glBufferData)
-            context->getProcAddress(QLatin1String("glBufferDataEXT"));
-    }
-    if (!funcs->bufferData) {
-        funcs->bufferData = (type_glBufferData)
-            context->getProcAddress(QLatin1String("glBufferDataARB"));
-    }
-
-    if (funcs->bufferData)
-        funcs->bufferData(target, size, data, usage);
-    else
-        funcs->bufferData = qglfResolveBufferData;
-}
-
-static void QGLF_APIENTRY qglfResolveBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data)
-{
-    typedef void (QGLF_APIENTRYP type_glBufferSubData)(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->bufferSubData = (type_glBufferSubData)
-        context->getProcAddress(QLatin1String("glBufferSubData"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->bufferSubData) {
-        funcs->bufferSubData = (type_glBufferSubData)
-            context->getProcAddress(QLatin1String("glBufferSubDataOES"));
-    }
-#endif
-    if (!funcs->bufferSubData) {
-        funcs->bufferSubData = (type_glBufferSubData)
-            context->getProcAddress(QLatin1String("glBufferSubDataEXT"));
-    }
-    if (!funcs->bufferSubData) {
-        funcs->bufferSubData = (type_glBufferSubData)
-            context->getProcAddress(QLatin1String("glBufferSubDataARB"));
-    }
-
-    if (funcs->bufferSubData)
-        funcs->bufferSubData(target, offset, size, data);
-    else
-        funcs->bufferSubData = qglfResolveBufferSubData;
-}
-
-static GLenum QGLF_APIENTRY qglfResolveCheckFramebufferStatus(GLenum target)
-{
-    typedef GLenum (QGLF_APIENTRYP type_glCheckFramebufferStatus)(GLenum target);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
-        context->getProcAddress(QLatin1String("glCheckFramebufferStatus"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->checkFramebufferStatus) {
-        funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
-            context->getProcAddress(QLatin1String("glCheckFramebufferStatusOES"));
-    }
-#endif
-    if (!funcs->checkFramebufferStatus) {
-        funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
-            context->getProcAddress(QLatin1String("glCheckFramebufferStatusEXT"));
-    }
-    if (!funcs->checkFramebufferStatus) {
-        funcs->checkFramebufferStatus = (type_glCheckFramebufferStatus)
-            context->getProcAddress(QLatin1String("glCheckFramebufferStatusARB"));
-    }
-
-    if (funcs->checkFramebufferStatus)
-        return funcs->checkFramebufferStatus(target);
-    funcs->checkFramebufferStatus = qglfResolveCheckFramebufferStatus;
-    return GLenum(0);
-}
-
-static void QGLF_APIENTRY qglfResolveCompileShader(GLuint shader)
-{
-    typedef void (QGLF_APIENTRYP type_glCompileShader)(GLuint shader);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->compileShader = (type_glCompileShader)
-        context->getProcAddress(QLatin1String("glCompileShader"));
-    if (!funcs->compileShader) {
-        funcs->compileShader = (type_glCompileShader)
-            context->getProcAddress(QLatin1String("glCompileShader"));
-    }
-
-    if (funcs->compileShader)
-        funcs->compileShader(shader);
-    else
-        funcs->compileShader = qglfResolveCompileShader;
-}
-
-static void QGLF_APIENTRY qglfResolveCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
-{
-    typedef void (QGLF_APIENTRYP type_glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
-        context->getProcAddress(QLatin1String("glCompressedTexImage2D"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->compressedTexImage2D) {
-        funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
-            context->getProcAddress(QLatin1String("glCompressedTexImage2DOES"));
-    }
-#endif
-    if (!funcs->compressedTexImage2D) {
-        funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
-            context->getProcAddress(QLatin1String("glCompressedTexImage2DEXT"));
-    }
-    if (!funcs->compressedTexImage2D) {
-        funcs->compressedTexImage2D = (type_glCompressedTexImage2D)
-            context->getProcAddress(QLatin1String("glCompressedTexImage2DARB"));
-    }
-
-    if (funcs->compressedTexImage2D)
-        funcs->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-    else
-        funcs->compressedTexImage2D = qglfResolveCompressedTexImage2D;
-}
-
-static void QGLF_APIENTRY qglfResolveCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
-{
-    typedef void (QGLF_APIENTRYP type_glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
-        context->getProcAddress(QLatin1String("glCompressedTexSubImage2D"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->compressedTexSubImage2D) {
-        funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
-            context->getProcAddress(QLatin1String("glCompressedTexSubImage2DOES"));
-    }
-#endif
-    if (!funcs->compressedTexSubImage2D) {
-        funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
-            context->getProcAddress(QLatin1String("glCompressedTexSubImage2DEXT"));
-    }
-    if (!funcs->compressedTexSubImage2D) {
-        funcs->compressedTexSubImage2D = (type_glCompressedTexSubImage2D)
-            context->getProcAddress(QLatin1String("glCompressedTexSubImage2DARB"));
-    }
-
-    if (funcs->compressedTexSubImage2D)
-        funcs->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-    else
-        funcs->compressedTexSubImage2D = qglfResolveCompressedTexSubImage2D;
-}
-
-static GLuint QGLF_APIENTRY qglfResolveCreateProgram()
-{
-    typedef GLuint (QGLF_APIENTRYP type_glCreateProgram)();
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->createProgram = (type_glCreateProgram)
-        context->getProcAddress(QLatin1String("glCreateProgram"));
-    if (!funcs->createProgram) {
-        funcs->createProgram = (type_glCreateProgram)
-            context->getProcAddress(QLatin1String("glCreateProgramObjectARB"));
-    }
-
-    if (funcs->createProgram)
-        return funcs->createProgram();
-    funcs->createProgram = qglfResolveCreateProgram;
-    return GLuint(0);
-}
-
-static GLuint QGLF_APIENTRY qglfResolveCreateShader(GLenum type)
-{
-    typedef GLuint (QGLF_APIENTRYP type_glCreateShader)(GLenum type);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->createShader = (type_glCreateShader)
-        context->getProcAddress(QLatin1String("glCreateShader"));
-    if (!funcs->createShader) {
-        funcs->createShader = (type_glCreateShader)
-            context->getProcAddress(QLatin1String("glCreateShaderObjectARB"));
-    }
-
-    if (funcs->createShader)
-        return funcs->createShader(type);
-    funcs->createShader = qglfResolveCreateShader;
-    return GLuint(0);
-}
-
-static void QGLF_APIENTRY qglfResolveDeleteBuffers(GLsizei n, const GLuint* buffers)
-{
-    typedef void (QGLF_APIENTRYP type_glDeleteBuffers)(GLsizei n, const GLuint* buffers);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->deleteBuffers = (type_glDeleteBuffers)
-        context->getProcAddress(QLatin1String("glDeleteBuffers"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->deleteBuffers) {
-        funcs->deleteBuffers = (type_glDeleteBuffers)
-            context->getProcAddress(QLatin1String("glDeleteBuffersOES"));
-    }
-#endif
-    if (!funcs->deleteBuffers) {
-        funcs->deleteBuffers = (type_glDeleteBuffers)
-            context->getProcAddress(QLatin1String("glDeleteBuffersEXT"));
-    }
-    if (!funcs->deleteBuffers) {
-        funcs->deleteBuffers = (type_glDeleteBuffers)
-            context->getProcAddress(QLatin1String("glDeleteBuffersARB"));
-    }
-
-    if (funcs->deleteBuffers)
-        funcs->deleteBuffers(n, buffers);
-    else
-        funcs->deleteBuffers = qglfResolveDeleteBuffers;
-}
-
-static void QGLF_APIENTRY qglfResolveDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
-{
-    typedef void (QGLF_APIENTRYP type_glDeleteFramebuffers)(GLsizei n, const GLuint* framebuffers);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
-        context->getProcAddress(QLatin1String("glDeleteFramebuffers"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->deleteFramebuffers) {
-        funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
-            context->getProcAddress(QLatin1String("glDeleteFramebuffersOES"));
-    }
-#endif
-    if (!funcs->deleteFramebuffers) {
-        funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
-            context->getProcAddress(QLatin1String("glDeleteFramebuffersEXT"));
-    }
-    if (!funcs->deleteFramebuffers) {
-        funcs->deleteFramebuffers = (type_glDeleteFramebuffers)
-            context->getProcAddress(QLatin1String("glDeleteFramebuffersARB"));
-    }
-
-    if (funcs->deleteFramebuffers)
-        funcs->deleteFramebuffers(n, framebuffers);
-    else
-        funcs->deleteFramebuffers = qglfResolveDeleteFramebuffers;
-}
-
-static void QGLF_APIENTRY qglfResolveDeleteProgram(GLuint program)
-{
-    typedef void (QGLF_APIENTRYP type_glDeleteProgram)(GLuint program);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->deleteProgram = (type_glDeleteProgram)
-        context->getProcAddress(QLatin1String("glDeleteProgram"));
-    if (!funcs->deleteProgram) {
-        funcs->deleteProgram = (type_glDeleteProgram)
-            context->getProcAddress(QLatin1String("glDeleteObjectARB"));
-    }
-
-    if (funcs->deleteProgram)
-        funcs->deleteProgram(program);
-    else
-        funcs->deleteProgram = qglfResolveDeleteProgram;
-}
-
-static void QGLF_APIENTRY qglfResolveDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
-{
-    typedef void (QGLF_APIENTRYP type_glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
-        context->getProcAddress(QLatin1String("glDeleteRenderbuffers"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->deleteRenderbuffers) {
-        funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
-            context->getProcAddress(QLatin1String("glDeleteRenderbuffersOES"));
-    }
-#endif
-    if (!funcs->deleteRenderbuffers) {
-        funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
-            context->getProcAddress(QLatin1String("glDeleteRenderbuffersEXT"));
-    }
-    if (!funcs->deleteRenderbuffers) {
-        funcs->deleteRenderbuffers = (type_glDeleteRenderbuffers)
-            context->getProcAddress(QLatin1String("glDeleteRenderbuffersARB"));
-    }
-
-    if (funcs->deleteRenderbuffers)
-        funcs->deleteRenderbuffers(n, renderbuffers);
-    else
-        funcs->deleteRenderbuffers = qglfResolveDeleteRenderbuffers;
-}
-
-static void QGLF_APIENTRY qglfResolveDeleteShader(GLuint shader)
-{
-    typedef void (QGLF_APIENTRYP type_glDeleteShader)(GLuint shader);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->deleteShader = (type_glDeleteShader)
-        context->getProcAddress(QLatin1String("glDeleteShader"));
-    if (!funcs->deleteShader) {
-        funcs->deleteShader = (type_glDeleteShader)
-            context->getProcAddress(QLatin1String("glDeleteObjectARB"));
-    }
-
-    if (funcs->deleteShader)
-        funcs->deleteShader(shader);
-    else
-        funcs->deleteShader = qglfResolveDeleteShader;
-}
-
-static void QGLF_APIENTRY qglfResolveDetachShader(GLuint program, GLuint shader)
-{
-    typedef void (QGLF_APIENTRYP type_glDetachShader)(GLuint program, GLuint shader);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->detachShader = (type_glDetachShader)
-        context->getProcAddress(QLatin1String("glDetachShader"));
-    if (!funcs->detachShader) {
-        funcs->detachShader = (type_glDetachShader)
-            context->getProcAddress(QLatin1String("glDetachObjectARB"));
-    }
-
-    if (funcs->detachShader)
-        funcs->detachShader(program, shader);
-    else
-        funcs->detachShader = qglfResolveDetachShader;
-}
-
-static void QGLF_APIENTRY qglfResolveDisableVertexAttribArray(GLuint index)
-{
-    typedef void (QGLF_APIENTRYP type_glDisableVertexAttribArray)(GLuint index);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->disableVertexAttribArray = (type_glDisableVertexAttribArray)
-        context->getProcAddress(QLatin1String("glDisableVertexAttribArray"));
-    if (!funcs->disableVertexAttribArray) {
-        funcs->disableVertexAttribArray = (type_glDisableVertexAttribArray)
-            context->getProcAddress(QLatin1String("glDisableVertexAttribArrayARB"));
-    }
-
-    if (funcs->disableVertexAttribArray)
-        funcs->disableVertexAttribArray(index);
-    else
-        funcs->disableVertexAttribArray = qglfResolveDisableVertexAttribArray;
-}
-
-static void QGLF_APIENTRY qglfResolveEnableVertexAttribArray(GLuint index)
-{
-    typedef void (QGLF_APIENTRYP type_glEnableVertexAttribArray)(GLuint index);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->enableVertexAttribArray = (type_glEnableVertexAttribArray)
-        context->getProcAddress(QLatin1String("glEnableVertexAttribArray"));
-    if (!funcs->enableVertexAttribArray) {
-        funcs->enableVertexAttribArray = (type_glEnableVertexAttribArray)
-            context->getProcAddress(QLatin1String("glEnableVertexAttribArrayARB"));
-    }
-
-    if (funcs->enableVertexAttribArray)
-        funcs->enableVertexAttribArray(index);
-    else
-        funcs->enableVertexAttribArray = qglfResolveEnableVertexAttribArray;
-}
-
-static void QGLF_APIENTRY qglfResolveFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    typedef void (QGLF_APIENTRYP type_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
-        context->getProcAddress(QLatin1String("glFramebufferRenderbuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->framebufferRenderbuffer) {
-        funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
-            context->getProcAddress(QLatin1String("glFramebufferRenderbufferOES"));
-    }
-#endif
-    if (!funcs->framebufferRenderbuffer) {
-        funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
-            context->getProcAddress(QLatin1String("glFramebufferRenderbufferEXT"));
-    }
-    if (!funcs->framebufferRenderbuffer) {
-        funcs->framebufferRenderbuffer = (type_glFramebufferRenderbuffer)
-            context->getProcAddress(QLatin1String("glFramebufferRenderbufferARB"));
-    }
-
-    if (funcs->framebufferRenderbuffer)
-        funcs->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-    else
-        funcs->framebufferRenderbuffer = qglfResolveFramebufferRenderbuffer;
-}
-
-static void QGLF_APIENTRY qglfResolveFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    typedef void (QGLF_APIENTRYP type_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
-        context->getProcAddress(QLatin1String("glFramebufferTexture2D"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->framebufferTexture2D) {
-        funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
-            context->getProcAddress(QLatin1String("glFramebufferTexture2DOES"));
-    }
-#endif
-    if (!funcs->framebufferTexture2D) {
-        funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
-            context->getProcAddress(QLatin1String("glFramebufferTexture2DEXT"));
-    }
-    if (!funcs->framebufferTexture2D) {
-        funcs->framebufferTexture2D = (type_glFramebufferTexture2D)
-            context->getProcAddress(QLatin1String("glFramebufferTexture2DARB"));
-    }
-
-    if (funcs->framebufferTexture2D)
-        funcs->framebufferTexture2D(target, attachment, textarget, texture, level);
-    else
-        funcs->framebufferTexture2D = qglfResolveFramebufferTexture2D;
-}
-
-static void QGLF_APIENTRY qglfResolveGenBuffers(GLsizei n, GLuint* buffers)
-{
-    typedef void (QGLF_APIENTRYP type_glGenBuffers)(GLsizei n, GLuint* buffers);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->genBuffers = (type_glGenBuffers)
-        context->getProcAddress(QLatin1String("glGenBuffers"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->genBuffers) {
-        funcs->genBuffers = (type_glGenBuffers)
-            context->getProcAddress(QLatin1String("glGenBuffersOES"));
-    }
-#endif
-    if (!funcs->genBuffers) {
-        funcs->genBuffers = (type_glGenBuffers)
-            context->getProcAddress(QLatin1String("glGenBuffersEXT"));
-    }
-    if (!funcs->genBuffers) {
-        funcs->genBuffers = (type_glGenBuffers)
-            context->getProcAddress(QLatin1String("glGenBuffersARB"));
-    }
-
-    if (funcs->genBuffers)
-        funcs->genBuffers(n, buffers);
-    else
-        funcs->genBuffers = qglfResolveGenBuffers;
-}
-
-static void QGLF_APIENTRY qglfResolveGenerateMipmap(GLenum target)
-{
-    typedef void (QGLF_APIENTRYP type_glGenerateMipmap)(GLenum target);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->generateMipmap = (type_glGenerateMipmap)
-        context->getProcAddress(QLatin1String("glGenerateMipmap"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->generateMipmap) {
-        funcs->generateMipmap = (type_glGenerateMipmap)
-            context->getProcAddress(QLatin1String("glGenerateMipmapOES"));
-    }
-#endif
-    if (!funcs->generateMipmap) {
-        funcs->generateMipmap = (type_glGenerateMipmap)
-            context->getProcAddress(QLatin1String("glGenerateMipmapEXT"));
-    }
-    if (!funcs->generateMipmap) {
-        funcs->generateMipmap = (type_glGenerateMipmap)
-            context->getProcAddress(QLatin1String("glGenerateMipmapARB"));
-    }
-
-    if (funcs->generateMipmap)
-        funcs->generateMipmap(target);
-    else
-        funcs->generateMipmap = qglfResolveGenerateMipmap;
-}
-
-static void QGLF_APIENTRY qglfResolveGenFramebuffers(GLsizei n, GLuint* framebuffers)
-{
-    typedef void (QGLF_APIENTRYP type_glGenFramebuffers)(GLsizei n, GLuint* framebuffers);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->genFramebuffers = (type_glGenFramebuffers)
-        context->getProcAddress(QLatin1String("glGenFramebuffers"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->genFramebuffers) {
-        funcs->genFramebuffers = (type_glGenFramebuffers)
-            context->getProcAddress(QLatin1String("glGenFramebuffersOES"));
-    }
-#endif
-    if (!funcs->genFramebuffers) {
-        funcs->genFramebuffers = (type_glGenFramebuffers)
-            context->getProcAddress(QLatin1String("glGenFramebuffersEXT"));
-    }
-    if (!funcs->genFramebuffers) {
-        funcs->genFramebuffers = (type_glGenFramebuffers)
-            context->getProcAddress(QLatin1String("glGenFramebuffersARB"));
-    }
-
-    if (funcs->genFramebuffers)
-        funcs->genFramebuffers(n, framebuffers);
-    else
-        funcs->genFramebuffers = qglfResolveGenFramebuffers;
-}
-
-static void QGLF_APIENTRY qglfResolveGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
-{
-    typedef void (QGLF_APIENTRYP type_glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->genRenderbuffers = (type_glGenRenderbuffers)
-        context->getProcAddress(QLatin1String("glGenRenderbuffers"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->genRenderbuffers) {
-        funcs->genRenderbuffers = (type_glGenRenderbuffers)
-            context->getProcAddress(QLatin1String("glGenRenderbuffersOES"));
-    }
-#endif
-    if (!funcs->genRenderbuffers) {
-        funcs->genRenderbuffers = (type_glGenRenderbuffers)
-            context->getProcAddress(QLatin1String("glGenRenderbuffersEXT"));
-    }
-    if (!funcs->genRenderbuffers) {
-        funcs->genRenderbuffers = (type_glGenRenderbuffers)
-            context->getProcAddress(QLatin1String("glGenRenderbuffersARB"));
-    }
-
-    if (funcs->genRenderbuffers)
-        funcs->genRenderbuffers(n, renderbuffers);
-    else
-        funcs->genRenderbuffers = qglfResolveGenRenderbuffers;
-}
-
-static void QGLF_APIENTRY qglfResolveGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
-{
-    typedef void (QGLF_APIENTRYP type_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getActiveAttrib = (type_glGetActiveAttrib)
-        context->getProcAddress(QLatin1String("glGetActiveAttrib"));
-    if (!funcs->getActiveAttrib) {
-        funcs->getActiveAttrib = (type_glGetActiveAttrib)
-            context->getProcAddress(QLatin1String("glGetActiveAttribARB"));
-    }
-
-    if (funcs->getActiveAttrib)
-        funcs->getActiveAttrib(program, index, bufsize, length, size, type, name);
-    else
-        funcs->getActiveAttrib = qglfResolveGetActiveAttrib;
-}
-
-static void QGLF_APIENTRY qglfResolveGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
-{
-    typedef void (QGLF_APIENTRYP type_glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getActiveUniform = (type_glGetActiveUniform)
-        context->getProcAddress(QLatin1String("glGetActiveUniform"));
-    if (!funcs->getActiveUniform) {
-        funcs->getActiveUniform = (type_glGetActiveUniform)
-            context->getProcAddress(QLatin1String("glGetActiveUniformARB"));
-    }
-
-    if (funcs->getActiveUniform)
-        funcs->getActiveUniform(program, index, bufsize, length, size, type, name);
-    else
-        funcs->getActiveUniform = qglfResolveGetActiveUniform;
-}
-
-static void QGLF_APIENTRY qglfResolveGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
-{
-    typedef void (QGLF_APIENTRYP type_glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getAttachedShaders = (type_glGetAttachedShaders)
-        context->getProcAddress(QLatin1String("glGetAttachedShaders"));
-    if (!funcs->getAttachedShaders) {
-        funcs->getAttachedShaders = (type_glGetAttachedShaders)
-            context->getProcAddress(QLatin1String("glGetAttachedObjectsARB"));
-    }
-
-    if (funcs->getAttachedShaders)
-        funcs->getAttachedShaders(program, maxcount, count, shaders);
-    else
-        funcs->getAttachedShaders = qglfResolveGetAttachedShaders;
-}
-
-static int QGLF_APIENTRY qglfResolveGetAttribLocation(GLuint program, const char* name)
-{
-    typedef int (QGLF_APIENTRYP type_glGetAttribLocation)(GLuint program, const char* name);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getAttribLocation = (type_glGetAttribLocation)
-        context->getProcAddress(QLatin1String("glGetAttribLocation"));
-    if (!funcs->getAttribLocation) {
-        funcs->getAttribLocation = (type_glGetAttribLocation)
-            context->getProcAddress(QLatin1String("glGetAttribLocationARB"));
-    }
-
-    if (funcs->getAttribLocation)
-        return funcs->getAttribLocation(program, name);
-    funcs->getAttribLocation = qglfResolveGetAttribLocation;
-    return int(0);
-}
-
-static void QGLF_APIENTRY qglfResolveGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
-        context->getProcAddress(QLatin1String("glGetBufferParameteriv"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->getBufferParameteriv) {
-        funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
-            context->getProcAddress(QLatin1String("glGetBufferParameterivOES"));
-    }
-#endif
-    if (!funcs->getBufferParameteriv) {
-        funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
-            context->getProcAddress(QLatin1String("glGetBufferParameterivEXT"));
-    }
-    if (!funcs->getBufferParameteriv) {
-        funcs->getBufferParameteriv = (type_glGetBufferParameteriv)
-            context->getProcAddress(QLatin1String("glGetBufferParameterivARB"));
-    }
-
-    if (funcs->getBufferParameteriv)
-        funcs->getBufferParameteriv(target, pname, params);
-    else
-        funcs->getBufferParameteriv = qglfResolveGetBufferParameteriv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
-        context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameteriv"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->getFramebufferAttachmentParameteriv) {
-        funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
-            context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameterivOES"));
-    }
-#endif
-    if (!funcs->getFramebufferAttachmentParameteriv) {
-        funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
-            context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameterivEXT"));
-    }
-    if (!funcs->getFramebufferAttachmentParameteriv) {
-        funcs->getFramebufferAttachmentParameteriv = (type_glGetFramebufferAttachmentParameteriv)
-            context->getProcAddress(QLatin1String("glGetFramebufferAttachmentParameterivARB"));
-    }
-
-    if (funcs->getFramebufferAttachmentParameteriv)
-        funcs->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
-    else
-        funcs->getFramebufferAttachmentParameteriv = qglfResolveGetFramebufferAttachmentParameteriv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetProgramiv(GLuint program, GLenum pname, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetProgramiv)(GLuint program, GLenum pname, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getProgramiv = (type_glGetProgramiv)
-        context->getProcAddress(QLatin1String("glGetProgramiv"));
-    if (!funcs->getProgramiv) {
-        funcs->getProgramiv = (type_glGetProgramiv)
-            context->getProcAddress(QLatin1String("glGetObjectParameterivARB"));
-    }
-
-    if (funcs->getProgramiv)
-        funcs->getProgramiv(program, pname, params);
-    else
-        funcs->getProgramiv = qglfResolveGetProgramiv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
-{
-    typedef void (QGLF_APIENTRYP type_glGetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getProgramInfoLog = (type_glGetProgramInfoLog)
-        context->getProcAddress(QLatin1String("glGetProgramInfoLog"));
-    if (!funcs->getProgramInfoLog) {
-        funcs->getProgramInfoLog = (type_glGetProgramInfoLog)
-            context->getProcAddress(QLatin1String("glGetInfoLogARB"));
-    }
-
-    if (funcs->getProgramInfoLog)
-        funcs->getProgramInfoLog(program, bufsize, length, infolog);
-    else
-        funcs->getProgramInfoLog = qglfResolveGetProgramInfoLog;
-}
-
-static void QGLF_APIENTRY qglfResolveGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
-        context->getProcAddress(QLatin1String("glGetRenderbufferParameteriv"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->getRenderbufferParameteriv) {
-        funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
-            context->getProcAddress(QLatin1String("glGetRenderbufferParameterivOES"));
-    }
-#endif
-    if (!funcs->getRenderbufferParameteriv) {
-        funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
-            context->getProcAddress(QLatin1String("glGetRenderbufferParameterivEXT"));
-    }
-    if (!funcs->getRenderbufferParameteriv) {
-        funcs->getRenderbufferParameteriv = (type_glGetRenderbufferParameteriv)
-            context->getProcAddress(QLatin1String("glGetRenderbufferParameterivARB"));
-    }
-
-    if (funcs->getRenderbufferParameteriv)
-        funcs->getRenderbufferParameteriv(target, pname, params);
-    else
-        funcs->getRenderbufferParameteriv = qglfResolveGetRenderbufferParameteriv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetShaderiv(GLuint shader, GLenum pname, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetShaderiv)(GLuint shader, GLenum pname, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getShaderiv = (type_glGetShaderiv)
-        context->getProcAddress(QLatin1String("glGetShaderiv"));
-    if (!funcs->getShaderiv) {
-        funcs->getShaderiv = (type_glGetShaderiv)
-            context->getProcAddress(QLatin1String("glGetObjectParameterivARB"));
-    }
-
-    if (funcs->getShaderiv)
-        funcs->getShaderiv(shader, pname, params);
-    else
-        funcs->getShaderiv = qglfResolveGetShaderiv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
-{
-    typedef void (QGLF_APIENTRYP type_glGetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getShaderInfoLog = (type_glGetShaderInfoLog)
-        context->getProcAddress(QLatin1String("glGetShaderInfoLog"));
-    if (!funcs->getShaderInfoLog) {
-        funcs->getShaderInfoLog = (type_glGetShaderInfoLog)
-            context->getProcAddress(QLatin1String("glGetInfoLogARB"));
-    }
-
-    if (funcs->getShaderInfoLog)
-        funcs->getShaderInfoLog(shader, bufsize, length, infolog);
-    else
-        funcs->getShaderInfoLog = qglfResolveGetShaderInfoLog;
-}
-
-static void QGLF_APIENTRY qglfSpecialGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
-{
-    Q_UNUSED(shadertype);
-    Q_UNUSED(precisiontype);
-    range[0] = range[1] = precision[0] = 0;
-}
-
-static void QGLF_APIENTRY qglfResolveGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
-{
-    typedef void (QGLF_APIENTRYP type_glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
-        context->getProcAddress(QLatin1String("glGetShaderPrecisionFormat"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->getShaderPrecisionFormat) {
-        funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
-            context->getProcAddress(QLatin1String("glGetShaderPrecisionFormatOES"));
-    }
-#endif
-    if (!funcs->getShaderPrecisionFormat) {
-        funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
-            context->getProcAddress(QLatin1String("glGetShaderPrecisionFormatEXT"));
-    }
-    if (!funcs->getShaderPrecisionFormat) {
-        funcs->getShaderPrecisionFormat = (type_glGetShaderPrecisionFormat)
-            context->getProcAddress(QLatin1String("glGetShaderPrecisionFormatARB"));
-    }
-
-    if (!funcs->getShaderPrecisionFormat)
-        funcs->getShaderPrecisionFormat = qglfSpecialGetShaderPrecisionFormat;
-
-    funcs->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-}
-
-static void QGLF_APIENTRY qglfResolveGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
-{
-    typedef void (QGLF_APIENTRYP type_glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getShaderSource = (type_glGetShaderSource)
-        context->getProcAddress(QLatin1String("glGetShaderSource"));
-    if (!funcs->getShaderSource) {
-        funcs->getShaderSource = (type_glGetShaderSource)
-            context->getProcAddress(QLatin1String("glGetShaderSourceARB"));
-    }
-
-    if (funcs->getShaderSource)
-        funcs->getShaderSource(shader, bufsize, length, source);
-    else
-        funcs->getShaderSource = qglfResolveGetShaderSource;
-}
-
-static void QGLF_APIENTRY qglfResolveGetUniformfv(GLuint program, GLint location, GLfloat* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetUniformfv)(GLuint program, GLint location, GLfloat* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getUniformfv = (type_glGetUniformfv)
-        context->getProcAddress(QLatin1String("glGetUniformfv"));
-    if (!funcs->getUniformfv) {
-        funcs->getUniformfv = (type_glGetUniformfv)
-            context->getProcAddress(QLatin1String("glGetUniformfvARB"));
-    }
-
-    if (funcs->getUniformfv)
-        funcs->getUniformfv(program, location, params);
-    else
-        funcs->getUniformfv = qglfResolveGetUniformfv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetUniformiv(GLuint program, GLint location, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetUniformiv)(GLuint program, GLint location, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getUniformiv = (type_glGetUniformiv)
-        context->getProcAddress(QLatin1String("glGetUniformiv"));
-    if (!funcs->getUniformiv) {
-        funcs->getUniformiv = (type_glGetUniformiv)
-            context->getProcAddress(QLatin1String("glGetUniformivARB"));
-    }
-
-    if (funcs->getUniformiv)
-        funcs->getUniformiv(program, location, params);
-    else
-        funcs->getUniformiv = qglfResolveGetUniformiv;
-}
-
-static int QGLF_APIENTRY qglfResolveGetUniformLocation(GLuint program, const char* name)
-{
-    typedef int (QGLF_APIENTRYP type_glGetUniformLocation)(GLuint program, const char* name);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getUniformLocation = (type_glGetUniformLocation)
-        context->getProcAddress(QLatin1String("glGetUniformLocation"));
-    if (!funcs->getUniformLocation) {
-        funcs->getUniformLocation = (type_glGetUniformLocation)
-            context->getProcAddress(QLatin1String("glGetUniformLocationARB"));
-    }
-
-    if (funcs->getUniformLocation)
-        return funcs->getUniformLocation(program, name);
-    funcs->getUniformLocation = qglfResolveGetUniformLocation;
-    return int(0);
-}
-
-static void QGLF_APIENTRY qglfResolveGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getVertexAttribfv = (type_glGetVertexAttribfv)
-        context->getProcAddress(QLatin1String("glGetVertexAttribfv"));
-    if (!funcs->getVertexAttribfv) {
-        funcs->getVertexAttribfv = (type_glGetVertexAttribfv)
-            context->getProcAddress(QLatin1String("glGetVertexAttribfvARB"));
-    }
-
-    if (funcs->getVertexAttribfv)
-        funcs->getVertexAttribfv(index, pname, params);
-    else
-        funcs->getVertexAttribfv = qglfResolveGetVertexAttribfv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
-{
-    typedef void (QGLF_APIENTRYP type_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getVertexAttribiv = (type_glGetVertexAttribiv)
-        context->getProcAddress(QLatin1String("glGetVertexAttribiv"));
-    if (!funcs->getVertexAttribiv) {
-        funcs->getVertexAttribiv = (type_glGetVertexAttribiv)
-            context->getProcAddress(QLatin1String("glGetVertexAttribivARB"));
-    }
-
-    if (funcs->getVertexAttribiv)
-        funcs->getVertexAttribiv(index, pname, params);
-    else
-        funcs->getVertexAttribiv = qglfResolveGetVertexAttribiv;
-}
-
-static void QGLF_APIENTRY qglfResolveGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
-{
-    typedef void (QGLF_APIENTRYP type_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->getVertexAttribPointerv = (type_glGetVertexAttribPointerv)
-        context->getProcAddress(QLatin1String("glGetVertexAttribPointerv"));
-    if (!funcs->getVertexAttribPointerv) {
-        funcs->getVertexAttribPointerv = (type_glGetVertexAttribPointerv)
-            context->getProcAddress(QLatin1String("glGetVertexAttribPointervARB"));
-    }
-
-    if (funcs->getVertexAttribPointerv)
-        funcs->getVertexAttribPointerv(index, pname, pointer);
-    else
-        funcs->getVertexAttribPointerv = qglfResolveGetVertexAttribPointerv;
-}
-
-static GLboolean QGLF_APIENTRY qglfResolveIsBuffer(GLuint buffer)
-{
-    typedef GLboolean (QGLF_APIENTRYP type_glIsBuffer)(GLuint buffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->isBuffer = (type_glIsBuffer)
-        context->getProcAddress(QLatin1String("glIsBuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->isBuffer) {
-        funcs->isBuffer = (type_glIsBuffer)
-            context->getProcAddress(QLatin1String("glIsBufferOES"));
-    }
-#endif
-    if (!funcs->isBuffer) {
-        funcs->isBuffer = (type_glIsBuffer)
-            context->getProcAddress(QLatin1String("glIsBufferEXT"));
-    }
-    if (!funcs->isBuffer) {
-        funcs->isBuffer = (type_glIsBuffer)
-            context->getProcAddress(QLatin1String("glIsBufferARB"));
-    }
-
-    if (funcs->isBuffer)
-        return funcs->isBuffer(buffer);
-    funcs->isBuffer = qglfResolveIsBuffer;
-    return GLboolean(0);
-}
-
-static GLboolean QGLF_APIENTRY qglfResolveIsFramebuffer(GLuint framebuffer)
-{
-    typedef GLboolean (QGLF_APIENTRYP type_glIsFramebuffer)(GLuint framebuffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->isFramebuffer = (type_glIsFramebuffer)
-        context->getProcAddress(QLatin1String("glIsFramebuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->isFramebuffer) {
-        funcs->isFramebuffer = (type_glIsFramebuffer)
-            context->getProcAddress(QLatin1String("glIsFramebufferOES"));
-    }
-#endif
-    if (!funcs->isFramebuffer) {
-        funcs->isFramebuffer = (type_glIsFramebuffer)
-            context->getProcAddress(QLatin1String("glIsFramebufferEXT"));
-    }
-    if (!funcs->isFramebuffer) {
-        funcs->isFramebuffer = (type_glIsFramebuffer)
-            context->getProcAddress(QLatin1String("glIsFramebufferARB"));
-    }
-
-    if (funcs->isFramebuffer)
-        return funcs->isFramebuffer(framebuffer);
-    funcs->isFramebuffer = qglfResolveIsFramebuffer;
-    return GLboolean(0);
-}
-
-static GLboolean QGLF_APIENTRY qglfSpecialIsProgram(GLuint program)
-{
-    return program != 0;
-}
-
-static GLboolean QGLF_APIENTRY qglfResolveIsProgram(GLuint program)
-{
-    typedef GLboolean (QGLF_APIENTRYP type_glIsProgram)(GLuint program);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->isProgram = (type_glIsProgram)
-        context->getProcAddress(QLatin1String("glIsProgram"));
-    if (!funcs->isProgram) {
-        funcs->isProgram = (type_glIsProgram)
-            context->getProcAddress(QLatin1String("glIsProgramARB"));
-    }
-
-    if (!funcs->isProgram)
-        funcs->isProgram = qglfSpecialIsProgram;
-
-    return funcs->isProgram(program);
-}
-
-static GLboolean QGLF_APIENTRY qglfResolveIsRenderbuffer(GLuint renderbuffer)
-{
-    typedef GLboolean (QGLF_APIENTRYP type_glIsRenderbuffer)(GLuint renderbuffer);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->isRenderbuffer = (type_glIsRenderbuffer)
-        context->getProcAddress(QLatin1String("glIsRenderbuffer"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->isRenderbuffer) {
-        funcs->isRenderbuffer = (type_glIsRenderbuffer)
-            context->getProcAddress(QLatin1String("glIsRenderbufferOES"));
-    }
-#endif
-    if (!funcs->isRenderbuffer) {
-        funcs->isRenderbuffer = (type_glIsRenderbuffer)
-            context->getProcAddress(QLatin1String("glIsRenderbufferEXT"));
-    }
-    if (!funcs->isRenderbuffer) {
-        funcs->isRenderbuffer = (type_glIsRenderbuffer)
-            context->getProcAddress(QLatin1String("glIsRenderbufferARB"));
-    }
-
-    if (funcs->isRenderbuffer)
-        return funcs->isRenderbuffer(renderbuffer);
-    funcs->isRenderbuffer = qglfResolveIsRenderbuffer;
-    return GLboolean(0);
-}
-
-static GLboolean QGLF_APIENTRY qglfSpecialIsShader(GLuint shader)
-{
-    return shader != 0;
-}
-
-static GLboolean QGLF_APIENTRY qglfResolveIsShader(GLuint shader)
-{
-    typedef GLboolean (QGLF_APIENTRYP type_glIsShader)(GLuint shader);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->isShader = (type_glIsShader)
-        context->getProcAddress(QLatin1String("glIsShader"));
-    if (!funcs->isShader) {
-        funcs->isShader = (type_glIsShader)
-            context->getProcAddress(QLatin1String("glIsShaderARB"));
-    }
-
-    if (!funcs->isShader)
-        funcs->isShader = qglfSpecialIsShader;
-
-    return funcs->isShader(shader);
-}
-
-static void QGLF_APIENTRY qglfResolveLinkProgram(GLuint program)
-{
-    typedef void (QGLF_APIENTRYP type_glLinkProgram)(GLuint program);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->linkProgram = (type_glLinkProgram)
-        context->getProcAddress(QLatin1String("glLinkProgram"));
-    if (!funcs->linkProgram) {
-        funcs->linkProgram = (type_glLinkProgram)
-            context->getProcAddress(QLatin1String("glLinkProgramARB"));
-    }
-
-    if (funcs->linkProgram)
-        funcs->linkProgram(program);
-    else
-        funcs->linkProgram = qglfResolveLinkProgram;
-}
-
-static void QGLF_APIENTRY qglfSpecialReleaseShaderCompiler()
-{
-}
-
-static void QGLF_APIENTRY qglfResolveReleaseShaderCompiler()
-{
-    typedef void (QGLF_APIENTRYP type_glReleaseShaderCompiler)();
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->releaseShaderCompiler = (type_glReleaseShaderCompiler)
-        context->getProcAddress(QLatin1String("glReleaseShaderCompiler"));
-    if (!funcs->releaseShaderCompiler) {
-        funcs->releaseShaderCompiler = (type_glReleaseShaderCompiler)
-            context->getProcAddress(QLatin1String("glReleaseShaderCompilerARB"));
-    }
-
-    if (!funcs->releaseShaderCompiler)
-        funcs->releaseShaderCompiler = qglfSpecialReleaseShaderCompiler;
-
-    funcs->releaseShaderCompiler();
-}
-
-static void QGLF_APIENTRY qglfResolveRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    typedef void (QGLF_APIENTRYP type_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->renderbufferStorage = (type_glRenderbufferStorage)
-        context->getProcAddress(QLatin1String("glRenderbufferStorage"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->renderbufferStorage) {
-        funcs->renderbufferStorage = (type_glRenderbufferStorage)
-            context->getProcAddress(QLatin1String("glRenderbufferStorageOES"));
-    }
-#endif
-    if (!funcs->renderbufferStorage) {
-        funcs->renderbufferStorage = (type_glRenderbufferStorage)
-            context->getProcAddress(QLatin1String("glRenderbufferStorageEXT"));
-    }
-    if (!funcs->renderbufferStorage) {
-        funcs->renderbufferStorage = (type_glRenderbufferStorage)
-            context->getProcAddress(QLatin1String("glRenderbufferStorageARB"));
-    }
-
-    if (funcs->renderbufferStorage)
-        funcs->renderbufferStorage(target, internalformat, width, height);
-    else
-        funcs->renderbufferStorage = qglfResolveRenderbufferStorage;
-}
-
-static void QGLF_APIENTRY qglfResolveSampleCoverage(GLclampf value, GLboolean invert)
-{
-    typedef void (QGLF_APIENTRYP type_glSampleCoverage)(GLclampf value, GLboolean invert);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->sampleCoverage = (type_glSampleCoverage)
-        context->getProcAddress(QLatin1String("glSampleCoverage"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->sampleCoverage) {
-        funcs->sampleCoverage = (type_glSampleCoverage)
-            context->getProcAddress(QLatin1String("glSampleCoverageOES"));
-    }
-#endif
-    if (!funcs->sampleCoverage) {
-        funcs->sampleCoverage = (type_glSampleCoverage)
-            context->getProcAddress(QLatin1String("glSampleCoverageEXT"));
-    }
-    if (!funcs->sampleCoverage) {
-        funcs->sampleCoverage = (type_glSampleCoverage)
-            context->getProcAddress(QLatin1String("glSampleCoverageARB"));
-    }
-
-    if (funcs->sampleCoverage)
-        funcs->sampleCoverage(value, invert);
-    else
-        funcs->sampleCoverage = qglfResolveSampleCoverage;
-}
-
-static void QGLF_APIENTRY qglfResolveShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
-{
-    typedef void (QGLF_APIENTRYP type_glShaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->shaderBinary = (type_glShaderBinary)
-        context->getProcAddress(QLatin1String("glShaderBinary"));
-    if (!funcs->shaderBinary) {
-        funcs->shaderBinary = (type_glShaderBinary)
-            context->getProcAddress(QLatin1String("glShaderBinaryARB"));
-    }
-
-    if (funcs->shaderBinary)
-        funcs->shaderBinary(n, shaders, binaryformat, binary, length);
-    else
-        funcs->shaderBinary = qglfResolveShaderBinary;
-}
-
-static void QGLF_APIENTRY qglfResolveShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
-{
-    typedef void (QGLF_APIENTRYP type_glShaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->shaderSource = (type_glShaderSource)
-        context->getProcAddress(QLatin1String("glShaderSource"));
-    if (!funcs->shaderSource) {
-        funcs->shaderSource = (type_glShaderSource)
-            context->getProcAddress(QLatin1String("glShaderSourceARB"));
-    }
-
-    if (funcs->shaderSource)
-        funcs->shaderSource(shader, count, string, length);
-    else
-        funcs->shaderSource = qglfResolveShaderSource;
-}
-
-static void QGLF_APIENTRY qglfResolveStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    typedef void (QGLF_APIENTRYP type_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
-        context->getProcAddress(QLatin1String("glStencilFuncSeparate"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->stencilFuncSeparate) {
-        funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
-            context->getProcAddress(QLatin1String("glStencilFuncSeparateOES"));
-    }
-#endif
-    if (!funcs->stencilFuncSeparate) {
-        funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
-            context->getProcAddress(QLatin1String("glStencilFuncSeparateEXT"));
-    }
-    if (!funcs->stencilFuncSeparate) {
-        funcs->stencilFuncSeparate = (type_glStencilFuncSeparate)
-            context->getProcAddress(QLatin1String("glStencilFuncSeparateARB"));
-    }
-
-    if (funcs->stencilFuncSeparate)
-        funcs->stencilFuncSeparate(face, func, ref, mask);
-    else
-        funcs->stencilFuncSeparate = qglfResolveStencilFuncSeparate;
-}
-
-static void QGLF_APIENTRY qglfResolveStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    typedef void (QGLF_APIENTRYP type_glStencilMaskSeparate)(GLenum face, GLuint mask);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
-        context->getProcAddress(QLatin1String("glStencilMaskSeparate"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->stencilMaskSeparate) {
-        funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
-            context->getProcAddress(QLatin1String("glStencilMaskSeparateOES"));
-    }
-#endif
-    if (!funcs->stencilMaskSeparate) {
-        funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
-            context->getProcAddress(QLatin1String("glStencilMaskSeparateEXT"));
-    }
-    if (!funcs->stencilMaskSeparate) {
-        funcs->stencilMaskSeparate = (type_glStencilMaskSeparate)
-            context->getProcAddress(QLatin1String("glStencilMaskSeparateARB"));
-    }
-
-    if (funcs->stencilMaskSeparate)
-        funcs->stencilMaskSeparate(face, mask);
-    else
-        funcs->stencilMaskSeparate = qglfResolveStencilMaskSeparate;
-}
-
-static void QGLF_APIENTRY qglfResolveStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
-{
-    typedef void (QGLF_APIENTRYP type_glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->stencilOpSeparate = (type_glStencilOpSeparate)
-        context->getProcAddress(QLatin1String("glStencilOpSeparate"));
-#ifdef QT_OPENGL_ES
-    if (!funcs->stencilOpSeparate) {
-        funcs->stencilOpSeparate = (type_glStencilOpSeparate)
-            context->getProcAddress(QLatin1String("glStencilOpSeparateOES"));
-    }
-#endif
-    if (!funcs->stencilOpSeparate) {
-        funcs->stencilOpSeparate = (type_glStencilOpSeparate)
-            context->getProcAddress(QLatin1String("glStencilOpSeparateEXT"));
-    }
-    if (!funcs->stencilOpSeparate) {
-        funcs->stencilOpSeparate = (type_glStencilOpSeparate)
-            context->getProcAddress(QLatin1String("glStencilOpSeparateARB"));
-    }
-
-    if (funcs->stencilOpSeparate)
-        funcs->stencilOpSeparate(face, fail, zfail, zpass);
-    else
-        funcs->stencilOpSeparate = qglfResolveStencilOpSeparate;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform1f(GLint location, GLfloat x)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform1f)(GLint location, GLfloat x);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform1f = (type_glUniform1f)
-        context->getProcAddress(QLatin1String("glUniform1f"));
-    if (!funcs->uniform1f) {
-        funcs->uniform1f = (type_glUniform1f)
-            context->getProcAddress(QLatin1String("glUniform1fARB"));
-    }
-
-    if (funcs->uniform1f)
-        funcs->uniform1f(location, x);
-    else
-        funcs->uniform1f = qglfResolveUniform1f;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform1fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform1fv)(GLint location, GLsizei count, const GLfloat* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform1fv = (type_glUniform1fv)
-        context->getProcAddress(QLatin1String("glUniform1fv"));
-    if (!funcs->uniform1fv) {
-        funcs->uniform1fv = (type_glUniform1fv)
-            context->getProcAddress(QLatin1String("glUniform1fvARB"));
-    }
-
-    if (funcs->uniform1fv)
-        funcs->uniform1fv(location, count, v);
-    else
-        funcs->uniform1fv = qglfResolveUniform1fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform1i(GLint location, GLint x)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform1i)(GLint location, GLint x);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform1i = (type_glUniform1i)
-        context->getProcAddress(QLatin1String("glUniform1i"));
-    if (!funcs->uniform1i) {
-        funcs->uniform1i = (type_glUniform1i)
-            context->getProcAddress(QLatin1String("glUniform1iARB"));
-    }
-
-    if (funcs->uniform1i)
-        funcs->uniform1i(location, x);
-    else
-        funcs->uniform1i = qglfResolveUniform1i;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform1iv(GLint location, GLsizei count, const GLint* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform1iv)(GLint location, GLsizei count, const GLint* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform1iv = (type_glUniform1iv)
-        context->getProcAddress(QLatin1String("glUniform1iv"));
-    if (!funcs->uniform1iv) {
-        funcs->uniform1iv = (type_glUniform1iv)
-            context->getProcAddress(QLatin1String("glUniform1ivARB"));
-    }
-
-    if (funcs->uniform1iv)
-        funcs->uniform1iv(location, count, v);
-    else
-        funcs->uniform1iv = qglfResolveUniform1iv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform2f(GLint location, GLfloat x, GLfloat y)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform2f)(GLint location, GLfloat x, GLfloat y);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform2f = (type_glUniform2f)
-        context->getProcAddress(QLatin1String("glUniform2f"));
-    if (!funcs->uniform2f) {
-        funcs->uniform2f = (type_glUniform2f)
-            context->getProcAddress(QLatin1String("glUniform2fARB"));
-    }
-
-    if (funcs->uniform2f)
-        funcs->uniform2f(location, x, y);
-    else
-        funcs->uniform2f = qglfResolveUniform2f;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform2fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform2fv)(GLint location, GLsizei count, const GLfloat* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform2fv = (type_glUniform2fv)
-        context->getProcAddress(QLatin1String("glUniform2fv"));
-    if (!funcs->uniform2fv) {
-        funcs->uniform2fv = (type_glUniform2fv)
-            context->getProcAddress(QLatin1String("glUniform2fvARB"));
-    }
-
-    if (funcs->uniform2fv)
-        funcs->uniform2fv(location, count, v);
-    else
-        funcs->uniform2fv = qglfResolveUniform2fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform2i(GLint location, GLint x, GLint y)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform2i)(GLint location, GLint x, GLint y);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform2i = (type_glUniform2i)
-        context->getProcAddress(QLatin1String("glUniform2i"));
-    if (!funcs->uniform2i) {
-        funcs->uniform2i = (type_glUniform2i)
-            context->getProcAddress(QLatin1String("glUniform2iARB"));
-    }
-
-    if (funcs->uniform2i)
-        funcs->uniform2i(location, x, y);
-    else
-        funcs->uniform2i = qglfResolveUniform2i;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform2iv(GLint location, GLsizei count, const GLint* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform2iv)(GLint location, GLsizei count, const GLint* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform2iv = (type_glUniform2iv)
-        context->getProcAddress(QLatin1String("glUniform2iv"));
-    if (!funcs->uniform2iv) {
-        funcs->uniform2iv = (type_glUniform2iv)
-            context->getProcAddress(QLatin1String("glUniform2ivARB"));
-    }
-
-    if (funcs->uniform2iv)
-        funcs->uniform2iv(location, count, v);
-    else
-        funcs->uniform2iv = qglfResolveUniform2iv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform3f = (type_glUniform3f)
-        context->getProcAddress(QLatin1String("glUniform3f"));
-    if (!funcs->uniform3f) {
-        funcs->uniform3f = (type_glUniform3f)
-            context->getProcAddress(QLatin1String("glUniform3fARB"));
-    }
-
-    if (funcs->uniform3f)
-        funcs->uniform3f(location, x, y, z);
-    else
-        funcs->uniform3f = qglfResolveUniform3f;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform3fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform3fv)(GLint location, GLsizei count, const GLfloat* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform3fv = (type_glUniform3fv)
-        context->getProcAddress(QLatin1String("glUniform3fv"));
-    if (!funcs->uniform3fv) {
-        funcs->uniform3fv = (type_glUniform3fv)
-            context->getProcAddress(QLatin1String("glUniform3fvARB"));
-    }
-
-    if (funcs->uniform3fv)
-        funcs->uniform3fv(location, count, v);
-    else
-        funcs->uniform3fv = qglfResolveUniform3fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform3i(GLint location, GLint x, GLint y, GLint z)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform3i)(GLint location, GLint x, GLint y, GLint z);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform3i = (type_glUniform3i)
-        context->getProcAddress(QLatin1String("glUniform3i"));
-    if (!funcs->uniform3i) {
-        funcs->uniform3i = (type_glUniform3i)
-            context->getProcAddress(QLatin1String("glUniform3iARB"));
-    }
-
-    if (funcs->uniform3i)
-        funcs->uniform3i(location, x, y, z);
-    else
-        funcs->uniform3i = qglfResolveUniform3i;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform3iv(GLint location, GLsizei count, const GLint* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform3iv)(GLint location, GLsizei count, const GLint* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform3iv = (type_glUniform3iv)
-        context->getProcAddress(QLatin1String("glUniform3iv"));
-    if (!funcs->uniform3iv) {
-        funcs->uniform3iv = (type_glUniform3iv)
-            context->getProcAddress(QLatin1String("glUniform3ivARB"));
-    }
-
-    if (funcs->uniform3iv)
-        funcs->uniform3iv(location, count, v);
-    else
-        funcs->uniform3iv = qglfResolveUniform3iv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform4f = (type_glUniform4f)
-        context->getProcAddress(QLatin1String("glUniform4f"));
-    if (!funcs->uniform4f) {
-        funcs->uniform4f = (type_glUniform4f)
-            context->getProcAddress(QLatin1String("glUniform4fARB"));
-    }
-
-    if (funcs->uniform4f)
-        funcs->uniform4f(location, x, y, z, w);
-    else
-        funcs->uniform4f = qglfResolveUniform4f;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform4fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform4fv)(GLint location, GLsizei count, const GLfloat* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform4fv = (type_glUniform4fv)
-        context->getProcAddress(QLatin1String("glUniform4fv"));
-    if (!funcs->uniform4fv) {
-        funcs->uniform4fv = (type_glUniform4fv)
-            context->getProcAddress(QLatin1String("glUniform4fvARB"));
-    }
-
-    if (funcs->uniform4fv)
-        funcs->uniform4fv(location, count, v);
-    else
-        funcs->uniform4fv = qglfResolveUniform4fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform4i = (type_glUniform4i)
-        context->getProcAddress(QLatin1String("glUniform4i"));
-    if (!funcs->uniform4i) {
-        funcs->uniform4i = (type_glUniform4i)
-            context->getProcAddress(QLatin1String("glUniform4iARB"));
-    }
-
-    if (funcs->uniform4i)
-        funcs->uniform4i(location, x, y, z, w);
-    else
-        funcs->uniform4i = qglfResolveUniform4i;
-}
-
-static void QGLF_APIENTRY qglfResolveUniform4iv(GLint location, GLsizei count, const GLint* v)
-{
-    typedef void (QGLF_APIENTRYP type_glUniform4iv)(GLint location, GLsizei count, const GLint* v);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniform4iv = (type_glUniform4iv)
-        context->getProcAddress(QLatin1String("glUniform4iv"));
-    if (!funcs->uniform4iv) {
-        funcs->uniform4iv = (type_glUniform4iv)
-            context->getProcAddress(QLatin1String("glUniform4ivARB"));
-    }
-
-    if (funcs->uniform4iv)
-        funcs->uniform4iv(location, count, v);
-    else
-        funcs->uniform4iv = qglfResolveUniform4iv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    typedef void (QGLF_APIENTRYP type_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniformMatrix2fv = (type_glUniformMatrix2fv)
-        context->getProcAddress(QLatin1String("glUniformMatrix2fv"));
-    if (!funcs->uniformMatrix2fv) {
-        funcs->uniformMatrix2fv = (type_glUniformMatrix2fv)
-            context->getProcAddress(QLatin1String("glUniformMatrix2fvARB"));
-    }
-
-    if (funcs->uniformMatrix2fv)
-        funcs->uniformMatrix2fv(location, count, transpose, value);
-    else
-        funcs->uniformMatrix2fv = qglfResolveUniformMatrix2fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    typedef void (QGLF_APIENTRYP type_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniformMatrix3fv = (type_glUniformMatrix3fv)
-        context->getProcAddress(QLatin1String("glUniformMatrix3fv"));
-    if (!funcs->uniformMatrix3fv) {
-        funcs->uniformMatrix3fv = (type_glUniformMatrix3fv)
-            context->getProcAddress(QLatin1String("glUniformMatrix3fvARB"));
-    }
-
-    if (funcs->uniformMatrix3fv)
-        funcs->uniformMatrix3fv(location, count, transpose, value);
-    else
-        funcs->uniformMatrix3fv = qglfResolveUniformMatrix3fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    typedef void (QGLF_APIENTRYP type_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->uniformMatrix4fv = (type_glUniformMatrix4fv)
-        context->getProcAddress(QLatin1String("glUniformMatrix4fv"));
-    if (!funcs->uniformMatrix4fv) {
-        funcs->uniformMatrix4fv = (type_glUniformMatrix4fv)
-            context->getProcAddress(QLatin1String("glUniformMatrix4fvARB"));
-    }
-
-    if (funcs->uniformMatrix4fv)
-        funcs->uniformMatrix4fv(location, count, transpose, value);
-    else
-        funcs->uniformMatrix4fv = qglfResolveUniformMatrix4fv;
-}
-
-static void QGLF_APIENTRY qglfResolveUseProgram(GLuint program)
-{
-    typedef void (QGLF_APIENTRYP type_glUseProgram)(GLuint program);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->useProgram = (type_glUseProgram)
-        context->getProcAddress(QLatin1String("glUseProgram"));
-    if (!funcs->useProgram) {
-        funcs->useProgram = (type_glUseProgram)
-            context->getProcAddress(QLatin1String("glUseProgramObjectARB"));
-    }
-
-    if (funcs->useProgram)
-        funcs->useProgram(program);
-    else
-        funcs->useProgram = qglfResolveUseProgram;
-}
-
-static void QGLF_APIENTRY qglfResolveValidateProgram(GLuint program)
-{
-    typedef void (QGLF_APIENTRYP type_glValidateProgram)(GLuint program);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->validateProgram = (type_glValidateProgram)
-        context->getProcAddress(QLatin1String("glValidateProgram"));
-    if (!funcs->validateProgram) {
-        funcs->validateProgram = (type_glValidateProgram)
-            context->getProcAddress(QLatin1String("glValidateProgramARB"));
-    }
-
-    if (funcs->validateProgram)
-        funcs->validateProgram(program);
-    else
-        funcs->validateProgram = qglfResolveValidateProgram;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib1f(GLuint indx, GLfloat x)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib1f)(GLuint indx, GLfloat x);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib1f = (type_glVertexAttrib1f)
-        context->getProcAddress(QLatin1String("glVertexAttrib1f"));
-    if (!funcs->vertexAttrib1f) {
-        funcs->vertexAttrib1f = (type_glVertexAttrib1f)
-            context->getProcAddress(QLatin1String("glVertexAttrib1fARB"));
-    }
-
-    if (funcs->vertexAttrib1f)
-        funcs->vertexAttrib1f(indx, x);
-    else
-        funcs->vertexAttrib1f = qglfResolveVertexAttrib1f;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib1fv(GLuint indx, const GLfloat* values)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib1fv)(GLuint indx, const GLfloat* values);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib1fv = (type_glVertexAttrib1fv)
-        context->getProcAddress(QLatin1String("glVertexAttrib1fv"));
-    if (!funcs->vertexAttrib1fv) {
-        funcs->vertexAttrib1fv = (type_glVertexAttrib1fv)
-            context->getProcAddress(QLatin1String("glVertexAttrib1fvARB"));
-    }
-
-    if (funcs->vertexAttrib1fv)
-        funcs->vertexAttrib1fv(indx, values);
-    else
-        funcs->vertexAttrib1fv = qglfResolveVertexAttrib1fv;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib2f = (type_glVertexAttrib2f)
-        context->getProcAddress(QLatin1String("glVertexAttrib2f"));
-    if (!funcs->vertexAttrib2f) {
-        funcs->vertexAttrib2f = (type_glVertexAttrib2f)
-            context->getProcAddress(QLatin1String("glVertexAttrib2fARB"));
-    }
-
-    if (funcs->vertexAttrib2f)
-        funcs->vertexAttrib2f(indx, x, y);
-    else
-        funcs->vertexAttrib2f = qglfResolveVertexAttrib2f;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib2fv(GLuint indx, const GLfloat* values)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib2fv)(GLuint indx, const GLfloat* values);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib2fv = (type_glVertexAttrib2fv)
-        context->getProcAddress(QLatin1String("glVertexAttrib2fv"));
-    if (!funcs->vertexAttrib2fv) {
-        funcs->vertexAttrib2fv = (type_glVertexAttrib2fv)
-            context->getProcAddress(QLatin1String("glVertexAttrib2fvARB"));
-    }
-
-    if (funcs->vertexAttrib2fv)
-        funcs->vertexAttrib2fv(indx, values);
-    else
-        funcs->vertexAttrib2fv = qglfResolveVertexAttrib2fv;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib3f = (type_glVertexAttrib3f)
-        context->getProcAddress(QLatin1String("glVertexAttrib3f"));
-    if (!funcs->vertexAttrib3f) {
-        funcs->vertexAttrib3f = (type_glVertexAttrib3f)
-            context->getProcAddress(QLatin1String("glVertexAttrib3fARB"));
-    }
-
-    if (funcs->vertexAttrib3f)
-        funcs->vertexAttrib3f(indx, x, y, z);
-    else
-        funcs->vertexAttrib3f = qglfResolveVertexAttrib3f;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib3fv(GLuint indx, const GLfloat* values)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib3fv)(GLuint indx, const GLfloat* values);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib3fv = (type_glVertexAttrib3fv)
-        context->getProcAddress(QLatin1String("glVertexAttrib3fv"));
-    if (!funcs->vertexAttrib3fv) {
-        funcs->vertexAttrib3fv = (type_glVertexAttrib3fv)
-            context->getProcAddress(QLatin1String("glVertexAttrib3fvARB"));
-    }
-
-    if (funcs->vertexAttrib3fv)
-        funcs->vertexAttrib3fv(indx, values);
-    else
-        funcs->vertexAttrib3fv = qglfResolveVertexAttrib3fv;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib4f = (type_glVertexAttrib4f)
-        context->getProcAddress(QLatin1String("glVertexAttrib4f"));
-    if (!funcs->vertexAttrib4f) {
-        funcs->vertexAttrib4f = (type_glVertexAttrib4f)
-            context->getProcAddress(QLatin1String("glVertexAttrib4fARB"));
-    }
-
-    if (funcs->vertexAttrib4f)
-        funcs->vertexAttrib4f(indx, x, y, z, w);
-    else
-        funcs->vertexAttrib4f = qglfResolveVertexAttrib4f;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttrib4fv(GLuint indx, const GLfloat* values)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttrib4fv)(GLuint indx, const GLfloat* values);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttrib4fv = (type_glVertexAttrib4fv)
-        context->getProcAddress(QLatin1String("glVertexAttrib4fv"));
-    if (!funcs->vertexAttrib4fv) {
-        funcs->vertexAttrib4fv = (type_glVertexAttrib4fv)
-            context->getProcAddress(QLatin1String("glVertexAttrib4fvARB"));
-    }
-
-    if (funcs->vertexAttrib4fv)
-        funcs->vertexAttrib4fv(indx, values);
-    else
-        funcs->vertexAttrib4fv = qglfResolveVertexAttrib4fv;
-}
-
-static void QGLF_APIENTRY qglfResolveVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
-{
-    typedef void (QGLF_APIENTRYP type_glVertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
-
-    const QGLContext *context = QGLContext::currentContext();
-    QGLFunctionsPrivate *funcs = qt_gl_functions(context);
-
-    funcs->vertexAttribPointer = (type_glVertexAttribPointer)
-        context->getProcAddress(QLatin1String("glVertexAttribPointer"));
-    if (!funcs->vertexAttribPointer) {
-        funcs->vertexAttribPointer = (type_glVertexAttribPointer)
-            context->getProcAddress(QLatin1String("glVertexAttribPointerARB"));
-    }
-
-    if (funcs->vertexAttribPointer)
-        funcs->vertexAttribPointer(indx, size, type, normalized, stride, ptr);
-    else
-        funcs->vertexAttribPointer = qglfResolveVertexAttribPointer;
-}
-
-#endif // !QT_OPENGL_ES_2
-
 QGLFunctionsPrivate::QGLFunctionsPrivate(const QGLContext *)
+    : funcs(0)
 {
-#ifndef QT_OPENGL_ES_2
-    activeTexture = qglfResolveActiveTexture;
-    attachShader = qglfResolveAttachShader;
-    bindAttribLocation = qglfResolveBindAttribLocation;
-    bindBuffer = qglfResolveBindBuffer;
-    bindFramebuffer = qglfResolveBindFramebuffer;
-    bindRenderbuffer = qglfResolveBindRenderbuffer;
-    blendColor = qglfResolveBlendColor;
-    blendEquation = qglfResolveBlendEquation;
-    blendEquationSeparate = qglfResolveBlendEquationSeparate;
-    blendFuncSeparate = qglfResolveBlendFuncSeparate;
-    bufferData = qglfResolveBufferData;
-    bufferSubData = qglfResolveBufferSubData;
-    checkFramebufferStatus = qglfResolveCheckFramebufferStatus;
-    compileShader = qglfResolveCompileShader;
-    compressedTexImage2D = qglfResolveCompressedTexImage2D;
-    compressedTexSubImage2D = qglfResolveCompressedTexSubImage2D;
-    createProgram = qglfResolveCreateProgram;
-    createShader = qglfResolveCreateShader;
-    deleteBuffers = qglfResolveDeleteBuffers;
-    deleteFramebuffers = qglfResolveDeleteFramebuffers;
-    deleteProgram = qglfResolveDeleteProgram;
-    deleteRenderbuffers = qglfResolveDeleteRenderbuffers;
-    deleteShader = qglfResolveDeleteShader;
-    detachShader = qglfResolveDetachShader;
-    disableVertexAttribArray = qglfResolveDisableVertexAttribArray;
-    enableVertexAttribArray = qglfResolveEnableVertexAttribArray;
-    framebufferRenderbuffer = qglfResolveFramebufferRenderbuffer;
-    framebufferTexture2D = qglfResolveFramebufferTexture2D;
-    genBuffers = qglfResolveGenBuffers;
-    generateMipmap = qglfResolveGenerateMipmap;
-    genFramebuffers = qglfResolveGenFramebuffers;
-    genRenderbuffers = qglfResolveGenRenderbuffers;
-    getActiveAttrib = qglfResolveGetActiveAttrib;
-    getActiveUniform = qglfResolveGetActiveUniform;
-    getAttachedShaders = qglfResolveGetAttachedShaders;
-    getAttribLocation = qglfResolveGetAttribLocation;
-    getBufferParameteriv = qglfResolveGetBufferParameteriv;
-    getFramebufferAttachmentParameteriv = qglfResolveGetFramebufferAttachmentParameteriv;
-    getProgramiv = qglfResolveGetProgramiv;
-    getProgramInfoLog = qglfResolveGetProgramInfoLog;
-    getRenderbufferParameteriv = qglfResolveGetRenderbufferParameteriv;
-    getShaderiv = qglfResolveGetShaderiv;
-    getShaderInfoLog = qglfResolveGetShaderInfoLog;
-    getShaderPrecisionFormat = qglfResolveGetShaderPrecisionFormat;
-    getShaderSource = qglfResolveGetShaderSource;
-    getUniformfv = qglfResolveGetUniformfv;
-    getUniformiv = qglfResolveGetUniformiv;
-    getUniformLocation = qglfResolveGetUniformLocation;
-    getVertexAttribfv = qglfResolveGetVertexAttribfv;
-    getVertexAttribiv = qglfResolveGetVertexAttribiv;
-    getVertexAttribPointerv = qglfResolveGetVertexAttribPointerv;
-    isBuffer = qglfResolveIsBuffer;
-    isFramebuffer = qglfResolveIsFramebuffer;
-    isProgram = qglfResolveIsProgram;
-    isRenderbuffer = qglfResolveIsRenderbuffer;
-    isShader = qglfResolveIsShader;
-    linkProgram = qglfResolveLinkProgram;
-    releaseShaderCompiler = qglfResolveReleaseShaderCompiler;
-    renderbufferStorage = qglfResolveRenderbufferStorage;
-    sampleCoverage = qglfResolveSampleCoverage;
-    shaderBinary = qglfResolveShaderBinary;
-    shaderSource = qglfResolveShaderSource;
-    stencilFuncSeparate = qglfResolveStencilFuncSeparate;
-    stencilMaskSeparate = qglfResolveStencilMaskSeparate;
-    stencilOpSeparate = qglfResolveStencilOpSeparate;
-    uniform1f = qglfResolveUniform1f;
-    uniform1fv = qglfResolveUniform1fv;
-    uniform1i = qglfResolveUniform1i;
-    uniform1iv = qglfResolveUniform1iv;
-    uniform2f = qglfResolveUniform2f;
-    uniform2fv = qglfResolveUniform2fv;
-    uniform2i = qglfResolveUniform2i;
-    uniform2iv = qglfResolveUniform2iv;
-    uniform3f = qglfResolveUniform3f;
-    uniform3fv = qglfResolveUniform3fv;
-    uniform3i = qglfResolveUniform3i;
-    uniform3iv = qglfResolveUniform3iv;
-    uniform4f = qglfResolveUniform4f;
-    uniform4fv = qglfResolveUniform4fv;
-    uniform4i = qglfResolveUniform4i;
-    uniform4iv = qglfResolveUniform4iv;
-    uniformMatrix2fv = qglfResolveUniformMatrix2fv;
-    uniformMatrix3fv = qglfResolveUniformMatrix3fv;
-    uniformMatrix4fv = qglfResolveUniformMatrix4fv;
-    useProgram = qglfResolveUseProgram;
-    validateProgram = qglfResolveValidateProgram;
-    vertexAttrib1f = qglfResolveVertexAttrib1f;
-    vertexAttrib1fv = qglfResolveVertexAttrib1fv;
-    vertexAttrib2f = qglfResolveVertexAttrib2f;
-    vertexAttrib2fv = qglfResolveVertexAttrib2fv;
-    vertexAttrib3f = qglfResolveVertexAttrib3f;
-    vertexAttrib3fv = qglfResolveVertexAttrib3fv;
-    vertexAttrib4f = qglfResolveVertexAttrib4f;
-    vertexAttrib4fv = qglfResolveVertexAttrib4fv;
-    vertexAttribPointer = qglfResolveVertexAttribPointer;
-#endif // !QT_OPENGL_ES_2
 }
 
 QT_END_NAMESPACE
diff --git a/src/opengl/qglfunctions.h b/src/opengl/qglfunctions.h
index 7fc7966a09..f822899e47 100644
--- a/src/opengl/qglfunctions.h
+++ b/src/opengl/qglfunctions.h
@@ -42,141 +42,14 @@
 #ifndef QGLFUNCTIONS_H
 #define QGLFUNCTIONS_H
 
-#ifdef __GLEW_H__
-#if defined(Q_CC_GNU)
-#warning qglfunctions.h is not compatible with GLEW, GLEW defines will be undefined
-#warning To use GLEW with Qt, do not include <QtOpenGL> or <QGLFunctions> after glew.h
-#endif
-#endif
-
 #include <QtOpenGL/qgl.h>
 #include <QtGui/qopenglcontext.h>
 #include <QtGui/qopenglfunctions.h>
 
 QT_BEGIN_NAMESPACE
 
-
-// Types that aren't defined in all system's gl.h files.
-typedef ptrdiff_t qgl_GLintptr;
-typedef ptrdiff_t qgl_GLsizeiptr;
-
-#if defined(APIENTRY) && !defined(QGLF_APIENTRY)
-#   define QGLF_APIENTRY APIENTRY
-#elif defined(GL_APIENTRY) && !defined(QGLF_APIENTRY)
-#   define QGLF_APIENTRY GL_APIENTRY
-#endif
-
-# ifndef QGLF_APIENTRYP
-#   ifdef QGLF_APIENTRY
-#     define QGLF_APIENTRYP QGLF_APIENTRY *
-#   else
-#     define QGLF_APIENTRY
-#     define QGLF_APIENTRYP *
-#   endif
-# endif
-
 struct QGLFunctionsPrivate;
 
-// Undefine any macros from GLEW, qglextensions_p.h, etc that
-// may interfere with the definition of QGLFunctions.
-#undef glActiveTexture
-#undef glAttachShader
-#undef glBindAttribLocation
-#undef glBindBuffer
-#undef glBindFramebuffer
-#undef glBindRenderbuffer
-#undef glBlendColor
-#undef glBlendEquation
-#undef glBlendEquationSeparate
-#undef glBlendFuncSeparate
-#undef glBufferData
-#undef glBufferSubData
-#undef glCheckFramebufferStatus
-#undef glClearDepthf
-#undef glCompileShader
-#undef glCompressedTexImage2D
-#undef glCompressedTexSubImage2D
-#undef glCreateProgram
-#undef glCreateShader
-#undef glDeleteBuffers
-#undef glDeleteFramebuffers
-#undef glDeleteProgram
-#undef glDeleteRenderbuffers
-#undef glDeleteShader
-#undef glDepthRangef
-#undef glDetachShader
-#undef glDisableVertexAttribArray
-#undef glEnableVertexAttribArray
-#undef glFramebufferRenderbuffer
-#undef glFramebufferTexture2D
-#undef glGenBuffers
-#undef glGenerateMipmap
-#undef glGenFramebuffers
-#undef glGenRenderbuffers
-#undef glGetActiveAttrib
-#undef glGetActiveUniform
-#undef glGetAttachedShaders
-#undef glGetAttribLocation
-#undef glGetBufferParameteriv
-#undef glGetFramebufferAttachmentParameteriv
-#undef glGetProgramiv
-#undef glGetProgramInfoLog
-#undef glGetRenderbufferParameteriv
-#undef glGetShaderiv
-#undef glGetShaderInfoLog
-#undef glGetShaderPrecisionFormat
-#undef glGetShaderSource
-#undef glGetUniformfv
-#undef glGetUniformiv
-#undef glGetUniformLocation
-#undef glGetVertexAttribfv
-#undef glGetVertexAttribiv
-#undef glGetVertexAttribPointerv
-#undef glIsBuffer
-#undef glIsFramebuffer
-#undef glIsProgram
-#undef glIsRenderbuffer
-#undef glIsShader
-#undef glLinkProgram
-#undef glReleaseShaderCompiler
-#undef glRenderbufferStorage
-#undef glSampleCoverage
-#undef glShaderBinary
-#undef glShaderSource
-#undef glStencilFuncSeparate
-#undef glStencilMaskSeparate
-#undef glStencilOpSeparate
-#undef glUniform1f
-#undef glUniform1fv
-#undef glUniform1i
-#undef glUniform1iv
-#undef glUniform2f
-#undef glUniform2fv
-#undef glUniform2i
-#undef glUniform2iv
-#undef glUniform3f
-#undef glUniform3fv
-#undef glUniform3i
-#undef glUniform3iv
-#undef glUniform4f
-#undef glUniform4fv
-#undef glUniform4i
-#undef glUniform4iv
-#undef glUniformMatrix2fv
-#undef glUniformMatrix3fv
-#undef glUniformMatrix4fv
-#undef glUseProgram
-#undef glValidateProgram
-#undef glVertexAttrib1f
-#undef glVertexAttrib1fv
-#undef glVertexAttrib2f
-#undef glVertexAttrib2fv
-#undef glVertexAttrib3f
-#undef glVertexAttrib3fv
-#undef glVertexAttrib4f
-#undef glVertexAttrib4fv
-#undef glVertexAttribPointer
-
 class Q_OPENGL_EXPORT QGLFunctions
 {
 public:
@@ -217,8 +90,8 @@ public:
     void glBlendEquation(GLenum mode);
     void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
     void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void glBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
-    void glBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
+    void glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage);
+    void glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data);
     GLenum glCheckFramebufferStatus(GLenum target);
     void glClearDepthf(GLclampf depth);
     void glCompileShader(GLuint shader);
@@ -315,1074 +188,591 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(QGLFunctions::OpenGLFeatures)
 struct QGLFunctionsPrivate
 {
     QGLFunctionsPrivate(const QGLContext *context = 0);
-
-#ifndef QT_OPENGL_ES_2
-    void (QGLF_APIENTRYP activeTexture)(GLenum texture);
-    void (QGLF_APIENTRYP attachShader)(GLuint program, GLuint shader);
-    void (QGLF_APIENTRYP bindAttribLocation)(GLuint program, GLuint index, const char* name);
-    void (QGLF_APIENTRYP bindBuffer)(GLenum target, GLuint buffer);
-    void (QGLF_APIENTRYP bindFramebuffer)(GLenum target, GLuint framebuffer);
-    void (QGLF_APIENTRYP bindRenderbuffer)(GLenum target, GLuint renderbuffer);
-    void (QGLF_APIENTRYP blendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void (QGLF_APIENTRYP blendEquation)(GLenum mode);
-    void (QGLF_APIENTRYP blendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
-    void (QGLF_APIENTRYP blendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void (QGLF_APIENTRYP bufferData)(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
-    void (QGLF_APIENTRYP bufferSubData)(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
-    GLenum (QGLF_APIENTRYP checkFramebufferStatus)(GLenum target);
-    void (QGLF_APIENTRYP compileShader)(GLuint shader);
-    void (QGLF_APIENTRYP compressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
-    void (QGLF_APIENTRYP compressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
-    GLuint (QGLF_APIENTRYP createProgram)();
-    GLuint (QGLF_APIENTRYP createShader)(GLenum type);
-    void (QGLF_APIENTRYP deleteBuffers)(GLsizei n, const GLuint* buffers);
-    void (QGLF_APIENTRYP deleteFramebuffers)(GLsizei n, const GLuint* framebuffers);
-    void (QGLF_APIENTRYP deleteProgram)(GLuint program);
-    void (QGLF_APIENTRYP deleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);
-    void (QGLF_APIENTRYP deleteShader)(GLuint shader);
-    void (QGLF_APIENTRYP detachShader)(GLuint program, GLuint shader);
-    void (QGLF_APIENTRYP disableVertexAttribArray)(GLuint index);
-    void (QGLF_APIENTRYP enableVertexAttribArray)(GLuint index);
-    void (QGLF_APIENTRYP framebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void (QGLF_APIENTRYP framebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void (QGLF_APIENTRYP genBuffers)(GLsizei n, GLuint* buffers);
-    void (QGLF_APIENTRYP generateMipmap)(GLenum target);
-    void (QGLF_APIENTRYP genFramebuffers)(GLsizei n, GLuint* framebuffers);
-    void (QGLF_APIENTRYP genRenderbuffers)(GLsizei n, GLuint* renderbuffers);
-    void (QGLF_APIENTRYP getActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-    void (QGLF_APIENTRYP getActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-    void (QGLF_APIENTRYP getAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-    int (QGLF_APIENTRYP getAttribLocation)(GLuint program, const char* name);
-    void (QGLF_APIENTRYP getBufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (QGLF_APIENTRYP getFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-    void (QGLF_APIENTRYP getProgramiv)(GLuint program, GLenum pname, GLint* params);
-    void (QGLF_APIENTRYP getProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
-    void (QGLF_APIENTRYP getRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (QGLF_APIENTRYP getShaderiv)(GLuint shader, GLenum pname, GLint* params);
-    void (QGLF_APIENTRYP getShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
-    void (QGLF_APIENTRYP getShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-    void (QGLF_APIENTRYP getShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
-    void (QGLF_APIENTRYP getUniformfv)(GLuint program, GLint location, GLfloat* params);
-    void (QGLF_APIENTRYP getUniformiv)(GLuint program, GLint location, GLint* params);
-    int (QGLF_APIENTRYP getUniformLocation)(GLuint program, const char* name);
-    void (QGLF_APIENTRYP getVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);
-    void (QGLF_APIENTRYP getVertexAttribiv)(GLuint index, GLenum pname, GLint* params);
-    void (QGLF_APIENTRYP getVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);
-    GLboolean (QGLF_APIENTRYP isBuffer)(GLuint buffer);
-    GLboolean (QGLF_APIENTRYP isFramebuffer)(GLuint framebuffer);
-    GLboolean (QGLF_APIENTRYP isProgram)(GLuint program);
-    GLboolean (QGLF_APIENTRYP isRenderbuffer)(GLuint renderbuffer);
-    GLboolean (QGLF_APIENTRYP isShader)(GLuint shader);
-    void (QGLF_APIENTRYP linkProgram)(GLuint program);
-    void (QGLF_APIENTRYP releaseShaderCompiler)();
-    void (QGLF_APIENTRYP renderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QGLF_APIENTRYP sampleCoverage)(GLclampf value, GLboolean invert);
-    void (QGLF_APIENTRYP shaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
-    void (QGLF_APIENTRYP shaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
-    void (QGLF_APIENTRYP stencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void (QGLF_APIENTRYP stencilMaskSeparate)(GLenum face, GLuint mask);
-    void (QGLF_APIENTRYP stencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-    void (QGLF_APIENTRYP uniform1f)(GLint location, GLfloat x);
-    void (QGLF_APIENTRYP uniform1fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QGLF_APIENTRYP uniform1i)(GLint location, GLint x);
-    void (QGLF_APIENTRYP uniform1iv)(GLint location, GLsizei count, const GLint* v);
-    void (QGLF_APIENTRYP uniform2f)(GLint location, GLfloat x, GLfloat y);
-    void (QGLF_APIENTRYP uniform2fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QGLF_APIENTRYP uniform2i)(GLint location, GLint x, GLint y);
-    void (QGLF_APIENTRYP uniform2iv)(GLint location, GLsizei count, const GLint* v);
-    void (QGLF_APIENTRYP uniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);
-    void (QGLF_APIENTRYP uniform3fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QGLF_APIENTRYP uniform3i)(GLint location, GLint x, GLint y, GLint z);
-    void (QGLF_APIENTRYP uniform3iv)(GLint location, GLsizei count, const GLint* v);
-    void (QGLF_APIENTRYP uniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QGLF_APIENTRYP uniform4fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QGLF_APIENTRYP uniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);
-    void (QGLF_APIENTRYP uniform4iv)(GLint location, GLsizei count, const GLint* v);
-    void (QGLF_APIENTRYP uniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (QGLF_APIENTRYP uniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (QGLF_APIENTRYP uniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (QGLF_APIENTRYP useProgram)(GLuint program);
-    void (QGLF_APIENTRYP validateProgram)(GLuint program);
-    void (QGLF_APIENTRYP vertexAttrib1f)(GLuint indx, GLfloat x);
-    void (QGLF_APIENTRYP vertexAttrib1fv)(GLuint indx, const GLfloat* values);
-    void (QGLF_APIENTRYP vertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
-    void (QGLF_APIENTRYP vertexAttrib2fv)(GLuint indx, const GLfloat* values);
-    void (QGLF_APIENTRYP vertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-    void (QGLF_APIENTRYP vertexAttrib3fv)(GLuint indx, const GLfloat* values);
-    void (QGLF_APIENTRYP vertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QGLF_APIENTRYP vertexAttrib4fv)(GLuint indx, const GLfloat* values);
-    void (QGLF_APIENTRYP vertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
-#endif
+    QOpenGLFunctions *funcs;
 };
 
 inline void QGLFunctions::glActiveTexture(GLenum texture)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glActiveTexture(texture);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->activeTexture(texture);
-#endif
+    d_ptr->funcs->glActiveTexture(texture);
 }
 
 inline void QGLFunctions::glAttachShader(GLuint program, GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glAttachShader(program, shader);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->attachShader(program, shader);
-#endif
+    d_ptr->funcs->glAttachShader(program, shader);
 }
 
 inline void QGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBindAttribLocation(program, index, name);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->bindAttribLocation(program, index, name);
-#endif
+    d_ptr->funcs->glBindAttribLocation(program, index, name);
 }
 
 inline void QGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBindBuffer(target, buffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->bindBuffer(target, buffer);
-#endif
+    d_ptr->funcs->glBindBuffer(target, buffer);
 }
 
 inline void QGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
     if (framebuffer == 0)
         framebuffer = QOpenGLContext::currentContext()->defaultFramebufferObject();
-#if defined(QT_OPENGL_ES_2)
-    ::glBindFramebuffer(target, framebuffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->bindFramebuffer(target, framebuffer);
-#endif
+    d_ptr->funcs->glBindFramebuffer(target, framebuffer);
 }
 
 inline void QGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBindRenderbuffer(target, renderbuffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->bindRenderbuffer(target, renderbuffer);
-#endif
+    d_ptr->funcs->glBindRenderbuffer(target, renderbuffer);
 }
 
 inline void QGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBlendColor(red, green, blue, alpha);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->blendColor(red, green, blue, alpha);
-#endif
+    d_ptr->funcs->glBlendColor(red, green, blue, alpha);
 }
 
 inline void QGLFunctions::glBlendEquation(GLenum mode)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBlendEquation(mode);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->blendEquation(mode);
-#endif
+    d_ptr->funcs->glBlendEquation(mode);
 }
 
 inline void QGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBlendEquationSeparate(modeRGB, modeAlpha);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->blendEquationSeparate(modeRGB, modeAlpha);
-#endif
+    d_ptr->funcs->glBlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 inline void QGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-#endif
+    d_ptr->funcs->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
-inline void QGLFunctions::glBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage)
+inline void QGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBufferData(target, size, data, usage);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->bufferData(target, size, data, usage);
-#endif
+    d_ptr->funcs->glBufferData(target, size, data, usage);
 }
 
-inline void QGLFunctions::glBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data)
+inline void QGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glBufferSubData(target, offset, size, data);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->bufferSubData(target, offset, size, data);
-#endif
+    d_ptr->funcs->glBufferSubData(target, offset, size, data);
 }
 
 inline GLenum QGLFunctions::glCheckFramebufferStatus(GLenum target)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glCheckFramebufferStatus(target);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->checkFramebufferStatus(target);
-#endif
+    return d_ptr->funcs->glCheckFramebufferStatus(target);
 }
 
 inline void QGLFunctions::glClearDepthf(GLclampf depth)
 {
-#ifndef QT_OPENGL_ES
-    ::glClearDepth(depth);
-#else
-    ::glClearDepthf(depth);
-#endif
+    Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
+    return d_ptr->funcs->glClearDepthf(depth);
 }
 
 inline void QGLFunctions::glCompileShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glCompileShader(shader);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->compileShader(shader);
-#endif
+    d_ptr->funcs->glCompileShader(shader);
 }
 
 inline void QGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-#endif
+    d_ptr->funcs->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-#endif
+    d_ptr->funcs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline GLuint QGLFunctions::glCreateProgram()
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glCreateProgram();
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->createProgram();
-#endif
+    return d_ptr->funcs->glCreateProgram();
 }
 
 inline GLuint QGLFunctions::glCreateShader(GLenum type)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glCreateShader(type);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->createShader(type);
-#endif
+    return d_ptr->funcs->glCreateShader(type);
 }
 
 inline void QGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDeleteBuffers(n, buffers);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->deleteBuffers(n, buffers);
-#endif
+    d_ptr->funcs->glDeleteBuffers(n, buffers);
 }
 
 inline void QGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDeleteFramebuffers(n, framebuffers);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->deleteFramebuffers(n, framebuffers);
-#endif
+    d_ptr->funcs->glDeleteFramebuffers(n, framebuffers);
 }
 
 inline void QGLFunctions::glDeleteProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDeleteProgram(program);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->deleteProgram(program);
-#endif
+    d_ptr->funcs->glDeleteProgram(program);
 }
 
 inline void QGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDeleteRenderbuffers(n, renderbuffers);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->deleteRenderbuffers(n, renderbuffers);
-#endif
+    d_ptr->funcs->glDeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QGLFunctions::glDeleteShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDeleteShader(shader);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->deleteShader(shader);
-#endif
+    d_ptr->funcs->glDeleteShader(shader);
 }
 
 inline void QGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
-#ifndef QT_OPENGL_ES
-    ::glDepthRange(zNear, zFar);
-#else
-    ::glDepthRangef(zNear, zFar);
-#endif
+    Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
+    return d_ptr->funcs->glDepthRangef(zNear, zFar);
 }
 
 inline void QGLFunctions::glDetachShader(GLuint program, GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDetachShader(program, shader);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->detachShader(program, shader);
-#endif
+    d_ptr->funcs->glDetachShader(program, shader);
 }
 
 inline void QGLFunctions::glDisableVertexAttribArray(GLuint index)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glDisableVertexAttribArray(index);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->disableVertexAttribArray(index);
-#endif
+    d_ptr->funcs->glDisableVertexAttribArray(index);
 }
 
 inline void QGLFunctions::glEnableVertexAttribArray(GLuint index)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glEnableVertexAttribArray(index);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->enableVertexAttribArray(index);
-#endif
+    d_ptr->funcs->glEnableVertexAttribArray(index);
 }
 
 inline void QGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-#endif
+    d_ptr->funcs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->framebufferTexture2D(target, attachment, textarget, texture, level);
-#endif
+    d_ptr->funcs->glFramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGenBuffers(n, buffers);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->genBuffers(n, buffers);
-#endif
+    d_ptr->funcs->glGenBuffers(n, buffers);
 }
 
 inline void QGLFunctions::glGenerateMipmap(GLenum target)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGenerateMipmap(target);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->generateMipmap(target);
-#endif
+    d_ptr->funcs->glGenerateMipmap(target);
 }
 
 inline void QGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGenFramebuffers(n, framebuffers);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->genFramebuffers(n, framebuffers);
-#endif
+    d_ptr->funcs->glGenFramebuffers(n, framebuffers);
 }
 
 inline void QGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGenRenderbuffers(n, renderbuffers);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->genRenderbuffers(n, renderbuffers);
-#endif
+    d_ptr->funcs->glGenRenderbuffers(n, renderbuffers);
 }
 
 inline void QGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getActiveAttrib(program, index, bufsize, length, size, type, name);
-#endif
+    d_ptr->funcs->glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 }
 
 inline void QGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getActiveUniform(program, index, bufsize, length, size, type, name);
-#endif
+    d_ptr->funcs->glGetActiveUniform(program, index, bufsize, length, size, type, name);
 }
 
 inline void QGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetAttachedShaders(program, maxcount, count, shaders);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getAttachedShaders(program, maxcount, count, shaders);
-#endif
+    d_ptr->funcs->glGetAttachedShaders(program, maxcount, count, shaders);
 }
 
 inline int QGLFunctions::glGetAttribLocation(GLuint program, const char* name)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glGetAttribLocation(program, name);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->getAttribLocation(program, name);
-#endif
+    return d_ptr->funcs->glGetAttribLocation(program, name);
 }
 
 inline void QGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetBufferParameteriv(target, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getBufferParameteriv(target, pname, params);
-#endif
+    d_ptr->funcs->glGetBufferParameteriv(target, pname, params);
 }
 
 inline void QGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
-#endif
+    d_ptr->funcs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetProgramiv(program, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getProgramiv(program, pname, params);
-#endif
+    d_ptr->funcs->glGetProgramiv(program, pname, params);
 }
 
 inline void QGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetProgramInfoLog(program, bufsize, length, infolog);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getProgramInfoLog(program, bufsize, length, infolog);
-#endif
+    d_ptr->funcs->glGetProgramInfoLog(program, bufsize, length, infolog);
 }
 
 inline void QGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetRenderbufferParameteriv(target, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getRenderbufferParameteriv(target, pname, params);
-#endif
+    d_ptr->funcs->glGetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetShaderiv(shader, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getShaderiv(shader, pname, params);
-#endif
+    d_ptr->funcs->glGetShaderiv(shader, pname, params);
 }
 
 inline void QGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetShaderInfoLog(shader, bufsize, length, infolog);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getShaderInfoLog(shader, bufsize, length, infolog);
-#endif
+    d_ptr->funcs->glGetShaderInfoLog(shader, bufsize, length, infolog);
 }
 
 inline void QGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-#endif
+    d_ptr->funcs->glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetShaderSource(shader, bufsize, length, source);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getShaderSource(shader, bufsize, length, source);
-#endif
+    d_ptr->funcs->glGetShaderSource(shader, bufsize, length, source);
 }
 
 inline void QGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetUniformfv(program, location, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getUniformfv(program, location, params);
-#endif
+    d_ptr->funcs->glGetUniformfv(program, location, params);
 }
 
 inline void QGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetUniformiv(program, location, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getUniformiv(program, location, params);
-#endif
+    d_ptr->funcs->glGetUniformiv(program, location, params);
 }
 
 inline int QGLFunctions::glGetUniformLocation(GLuint program, const char* name)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glGetUniformLocation(program, name);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->getUniformLocation(program, name);
-#endif
+    return d_ptr->funcs->glGetUniformLocation(program, name);
 }
 
 inline void QGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetVertexAttribfv(index, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getVertexAttribfv(index, pname, params);
-#endif
+    d_ptr->funcs->glGetVertexAttribfv(index, pname, params);
 }
 
 inline void QGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetVertexAttribiv(index, pname, params);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getVertexAttribiv(index, pname, params);
-#endif
+    d_ptr->funcs->glGetVertexAttribiv(index, pname, params);
 }
 
 inline void QGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glGetVertexAttribPointerv(index, pname, pointer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->getVertexAttribPointerv(index, pname, pointer);
-#endif
+    d_ptr->funcs->glGetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline GLboolean QGLFunctions::glIsBuffer(GLuint buffer)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glIsBuffer(buffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->isBuffer(buffer);
-#endif
+    return d_ptr->funcs->glIsBuffer(buffer);
 }
 
 inline GLboolean QGLFunctions::glIsFramebuffer(GLuint framebuffer)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glIsFramebuffer(framebuffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->isFramebuffer(framebuffer);
-#endif
+    return d_ptr->funcs->glIsFramebuffer(framebuffer);
 }
 
 inline GLboolean QGLFunctions::glIsProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glIsProgram(program);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->isProgram(program);
-#endif
+    return d_ptr->funcs->glIsProgram(program);
 }
 
 inline GLboolean QGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glIsRenderbuffer(renderbuffer);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->isRenderbuffer(renderbuffer);
-#endif
+    return d_ptr->funcs->glIsRenderbuffer(renderbuffer);
 }
 
 inline GLboolean QGLFunctions::glIsShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
-    return ::glIsShader(shader);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    return d_ptr->isShader(shader);
-#endif
+    return d_ptr->funcs->glIsShader(shader);
 }
 
 inline void QGLFunctions::glLinkProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glLinkProgram(program);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->linkProgram(program);
-#endif
+    d_ptr->funcs->glLinkProgram(program);
 }
 
 inline void QGLFunctions::glReleaseShaderCompiler()
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glReleaseShaderCompiler();
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->releaseShaderCompiler();
-#endif
+    d_ptr->funcs->glReleaseShaderCompiler();
 }
 
 inline void QGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glRenderbufferStorage(target, internalformat, width, height);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->renderbufferStorage(target, internalformat, width, height);
-#endif
+    d_ptr->funcs->glRenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glSampleCoverage(value, invert);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->sampleCoverage(value, invert);
-#endif
+    d_ptr->funcs->glSampleCoverage(value, invert);
 }
 
 inline void QGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glShaderBinary(n, shaders, binaryformat, binary, length);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->shaderBinary(n, shaders, binaryformat, binary, length);
-#endif
+    d_ptr->funcs->glShaderBinary(n, shaders, binaryformat, binary, length);
 }
 
 inline void QGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glShaderSource(shader, count, string, length);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->shaderSource(shader, count, string, length);
-#endif
+    d_ptr->funcs->glShaderSource(shader, count, string, length);
 }
 
 inline void QGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glStencilFuncSeparate(face, func, ref, mask);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->stencilFuncSeparate(face, func, ref, mask);
-#endif
+    d_ptr->funcs->glStencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glStencilMaskSeparate(face, mask);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->stencilMaskSeparate(face, mask);
-#endif
+    d_ptr->funcs->glStencilMaskSeparate(face, mask);
 }
 
 inline void QGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glStencilOpSeparate(face, fail, zfail, zpass);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->stencilOpSeparate(face, fail, zfail, zpass);
-#endif
+    d_ptr->funcs->glStencilOpSeparate(face, fail, zfail, zpass);
 }
 
 inline void QGLFunctions::glUniform1f(GLint location, GLfloat x)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform1f(location, x);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform1f(location, x);
-#endif
+    d_ptr->funcs->glUniform1f(location, x);
 }
 
 inline void QGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform1fv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform1fv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform1fv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform1i(GLint location, GLint x)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform1i(location, x);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform1i(location, x);
-#endif
+    d_ptr->funcs->glUniform1i(location, x);
 }
 
 inline void QGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform1iv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform1iv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform1iv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform2f(location, x, y);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform2f(location, x, y);
-#endif
+    d_ptr->funcs->glUniform2f(location, x, y);
 }
 
 inline void QGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform2fv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform2fv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform2fv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform2i(location, x, y);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform2i(location, x, y);
-#endif
+    d_ptr->funcs->glUniform2i(location, x, y);
 }
 
 inline void QGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform2iv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform2iv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform2iv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform3f(location, x, y, z);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform3f(location, x, y, z);
-#endif
+    d_ptr->funcs->glUniform3f(location, x, y, z);
 }
 
 inline void QGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform3fv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform3fv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform3fv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform3i(location, x, y, z);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform3i(location, x, y, z);
-#endif
+    d_ptr->funcs->glUniform3i(location, x, y, z);
 }
 
 inline void QGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform3iv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform3iv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform3iv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform4f(location, x, y, z, w);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform4f(location, x, y, z, w);
-#endif
+    d_ptr->funcs->glUniform4f(location, x, y, z, w);
 }
 
 inline void QGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform4fv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform4fv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform4fv(location, count, v);
 }
 
 inline void QGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform4i(location, x, y, z, w);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform4i(location, x, y, z, w);
-#endif
+    d_ptr->funcs->glUniform4i(location, x, y, z, w);
 }
 
 inline void QGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniform4iv(location, count, v);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniform4iv(location, count, v);
-#endif
+    d_ptr->funcs->glUniform4iv(location, count, v);
 }
 
 inline void QGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniformMatrix2fv(location, count, transpose, value);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniformMatrix2fv(location, count, transpose, value);
-#endif
+    d_ptr->funcs->glUniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniformMatrix3fv(location, count, transpose, value);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniformMatrix3fv(location, count, transpose, value);
-#endif
+    d_ptr->funcs->glUniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUniformMatrix4fv(location, count, transpose, value);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->uniformMatrix4fv(location, count, transpose, value);
-#endif
+    d_ptr->funcs->glUniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QGLFunctions::glUseProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glUseProgram(program);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->useProgram(program);
-#endif
+    d_ptr->funcs->glUseProgram(program);
 }
 
 inline void QGLFunctions::glValidateProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glValidateProgram(program);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->validateProgram(program);
-#endif
+    d_ptr->funcs->glValidateProgram(program);
 }
 
 inline void QGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib1f(indx, x);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib1f(indx, x);
-#endif
+    d_ptr->funcs->glVertexAttrib1f(indx, x);
 }
 
 inline void QGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib1fv(indx, values);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib1fv(indx, values);
-#endif
+    d_ptr->funcs->glVertexAttrib1fv(indx, values);
 }
 
 inline void QGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib2f(indx, x, y);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib2f(indx, x, y);
-#endif
+    d_ptr->funcs->glVertexAttrib2f(indx, x, y);
 }
 
 inline void QGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib2fv(indx, values);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib2fv(indx, values);
-#endif
+    d_ptr->funcs->glVertexAttrib2fv(indx, values);
 }
 
 inline void QGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib3f(indx, x, y, z);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib3f(indx, x, y, z);
-#endif
+    d_ptr->funcs->glVertexAttrib3f(indx, x, y, z);
 }
 
 inline void QGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib3fv(indx, values);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib3fv(indx, values);
-#endif
+    d_ptr->funcs->glVertexAttrib3fv(indx, values);
 }
 
 inline void QGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib4f(indx, x, y, z, w);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib4f(indx, x, y, z, w);
-#endif
+    d_ptr->funcs->glVertexAttrib4f(indx, x, y, z, w);
 }
 
 inline void QGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttrib4fv(indx, values);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttrib4fv(indx, values);
-#endif
+    d_ptr->funcs->glVertexAttrib4fv(indx, values);
 }
 
 inline void QGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
 {
-#if defined(QT_OPENGL_ES_2)
-    ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
-#else
     Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
-    d_ptr->vertexAttribPointer(indx, size, type, normalized, stride, ptr);
-#endif
+    d_ptr->funcs->glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 }
 
 #ifndef GL_ACTIVE_ATTRIBUTE_MAX_LENGTH