Extend QOpenGLFunctions with GL1 functions

This introduces the ability to indirectly invoke all common GL1-GLES2
functions via QOpenGLFunctions. The GL1 functions are not yet resolved,
since this would not work anyway when linking to an OpenGL implementation
directly. However this may change later but that will be a completely
internal change without affecting any public APIs.

Also migrate some of the opengl examples to use QOpenGLFunctions for
everything. Once dynamic GL loading becomes available on some platforms,
these examples should continue to function without any changes since they
do not anymore invoke any OpenGL functions directly.

Task-number: QTBUG-36483
Change-Id: Ie630029651e5a4863a480aac5306edd67ee36813
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
Reviewed-by: Jørgen Lind <jorgen.lind@digia.com>

2 files changed, 1286 insertions, 98 deletions

diff --git a/src/gui/opengl/qopenglfunctions.cpp b/src/gui/opengl/qopenglfunctions.cpp
index 9a52ae2a9f..504e62adf4 100644
--- a/src/gui/opengl/qopenglfunctions.cpp
+++ b/src/gui/opengl/qopenglfunctions.cpp
@@ -124,9 +124,13 @@ QT_BEGIN_NAMESPACE
     glFuncs.glActiveTexture(GL_TEXTURE1);
     \endcode
 
-    QOpenGLFunctions provides wrappers for all OpenGL/ES 2.0 functions,
-    except those like \c{glDrawArrays()}, \c{glViewport()}, and
-    \c{glBindTexture()} that don't have portability issues.
+    QOpenGLFunctions provides wrappers for all OpenGL/ES 2.0
+    functions, including the common subset of OpenGL 1.x and ES
+    2.0. While such functions, for example glClear() or
+    glDrawArrays(), can be called also directly, as long as the
+    application links to the platform-specific OpenGL library, calling
+    them via QOpenGLFunctions enables the possibility of dynamically
+    loading the OpenGL implementation.
 
     The hasOpenGLFeature() and openGLFeatures() functions can be used
     to determine if the OpenGL implementation has a major OpenGL/ES 2.0
@@ -488,6 +492,501 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 }
 
 /*!
+    \fn void QOpenGLFunctions::glBindTexture(GLenum target, GLuint texture)
+
+    Convenience function that calls glBindTexture(\a target, \a texture).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glBindTexture.xml}{glBindTexture()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glBlendFunc(GLenum sfactor, GLenum dfactor)
+
+    Convenience function that calls glBlendFunc(\a sfactor, \a dfactor).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glBlendFunc.xml}{glBlendFunc()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glClear(GLbitfield mask)
+
+    Convenience function that calls glClear(\a mask).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glClear.xml}{glClear()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+
+    Convenience function that calls glClearColor(\a red, \a green, \a blue, \a alpha).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glClearColor.xml}{glClearColor()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glClearStencil(GLint s)
+
+    Convenience function that calls glClearStencil(\a s).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glClearStencil.xml}{glClearStencil()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+
+    Convenience function that calls glColorMask(\a red, \a green, \a blue, \a alpha).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glColorMask.xml}{glColorMask()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+
+    Convenience function that calls glCopyTexImage2D(\a target, \a level, \a internalformat, \a x, \a y, \a width, \a height, \a border).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glCopyTexImage2D.xml}{glCopyTexImage2D()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+
+    Convenience function that calls glCopyTexSubImage2D(\a target, \a level, \a xoffset, \a yoffset, \a x, \a y, \a width, \a height).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glCopyTexSubImage2D.xml}{glCopyTexSubImage2D()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glCullFace(GLenum mode)
+
+    Convenience function that calls glCullFace(\a mode).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glCullFace.xml}{glCullFace()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glDeleteTextures(GLsizei n, const GLuint* textures)
+
+    Convenience function that calls glDeleteTextures(\a n, \a textures).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glDeleteTextures.xml}{glDeleteTextures()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glDepthFunc(GLenum func)
+
+    Convenience function that calls glDepthFunc(\a func).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glDepthFunc.xml}{glDepthFunc()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glDepthMask(GLboolean flag)
+
+    Convenience function that calls glDepthMask(\a flag).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glDepthMask.xml}{glDepthMask()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glDisable(GLenum cap)
+
+    Convenience function that calls glDisable(\a cap).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glDisable.xml}{glDisable()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glDrawArrays(GLenum mode, GLint first, GLsizei count)
+
+    Convenience function that calls glDrawArrays(\a mode, \a first, \a count).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glDrawArrays.xml}{glDrawArrays()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
+
+    Convenience function that calls glDrawElements(\a mode, \a count, \a type, \a indices).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glDrawElements.xml}{glDrawElements()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glEnable(GLenum cap)
+
+    Convenience function that calls glEnable(\a cap).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glEnable.xml}{glEnable()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glFinish()
+
+    Convenience function that calls glFinish().
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glFinish.xml}{glFinish()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glFlush()
+
+    Convenience function that calls glFlush().
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glFlush.xml}{glFlush()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glFrontFace(GLenum mode)
+
+    Convenience function that calls glFrontFace(\a mode).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glFrontFace.xml}{glFrontFace()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glGenTextures(GLsizei n, GLuint* textures)
+
+    Convenience function that calls glGenTextures(\a n, \a textures).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGenTextures.xml}{glGenTextures()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glGetBooleanv(GLenum pname, GLboolean* params)
+
+    Convenience function that calls glGetBooleanv(\a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetBooleanv.xml}{glGetBooleanv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn GLenum QOpenGLFunctions::glGetError()
+
+    Convenience function that calls glGetError().
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetError.xml}{glGetError()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glGetFloatv(GLenum pname, GLfloat* params)
+
+    Convenience function that calls glGetFloatv(\a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetFloatv.xml}{glGetFloatv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glGetIntegerv(GLenum pname, GLint* params)
+
+    Convenience function that calls glGetIntegerv(\a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetIntegerv.xml}{glGetIntegerv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn const GLubyte *QOpenGLFunctions::glGetString(GLenum name)
+
+    Convenience function that calls glGetString(\a name).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetString.xml}{glGetString()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+
+    Convenience function that calls glGetTexParameterfv(\a target, \a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetTexParameterfv.xml}{glGetTexParameterfv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+
+    Convenience function that calls glGetTexParameteriv(\a target, \a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glGetTexParameteriv.xml}{glGetTexParameteriv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glHint(GLenum target, GLenum mode)
+
+    Convenience function that calls glHint(\a target, \a mode).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glHint.xml}{glHint()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn GLboolean QOpenGLFunctions::glIsEnabled(GLenum cap)
+
+    Convenience function that calls glIsEnabled(\a cap).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glIsEnabled.xml}{glIsEnabled()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn GLboolean QOpenGLFunctions::glIsTexture(GLuint texture)
+
+    Convenience function that calls glIsTexture(\a texture).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glIsTexture.xml}{glIsTexture()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glLineWidth(GLfloat width)
+
+    Convenience function that calls glLineWidth(\a width).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glLineWidth.xml}{glLineWidth()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glPixelStorei(GLenum pname, GLint param)
+
+    Convenience function that calls glPixelStorei(\a pname, \a param).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glPixelStorei.xml}{glPixelStorei()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glPolygonOffset(GLfloat factor, GLfloat units)
+
+    Convenience function that calls glPolygonOffset(\a factor, \a units).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glPolygonOffset.xml}{glPolygonOffset()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
+
+    Convenience function that calls glReadPixels(\a x, \a y, \a width, \a height, \a format, \a type, \a pixels).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glReadPixels.xml}{glReadPixels()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+
+    Convenience function that calls glScissor(\a x, \a y, \a width, \a height).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glScissor.xml}{glScissor()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glStencilFunc(GLenum func, GLint ref, GLuint mask)
+
+    Convenience function that calls glStencilFunc(\a func, \a ref, \a mask).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glStencilFunc.xml}{glStencilFunc()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glStencilMask(GLuint mask)
+
+    Convenience function that calls glStencilMask(\a mask).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glStencilMask.xml}{glStencilMask()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+
+    Convenience function that calls glStencilOp(\a fail, \a zfail, \a zpass).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glStencilOp.xml}{glStencilOp()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
+
+    Convenience function that calls glTexImage2D(\a target, \a level, \a internalformat, \a width, \a height, \a border, \a format, \a type, \a pixels).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glTexImage2D.xml}{glTexImage2D()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+
+    Convenience function that calls glTexParameterf(\a target, \a pname, \a param).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glTexParameterf.xml}{glTexParameterf()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+
+    Convenience function that calls glTexParameterfv(\a target, \a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glTexParameterfv.xml}{glTexParameterfv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glTexParameteri(GLenum target, GLenum pname, GLint param)
+
+    Convenience function that calls glTexParameteri(\a target, \a pname, \a param).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glTexParameteri.xml}{glTexParameteri()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
+
+    Convenience function that calls glTexParameteriv(\a target, \a pname, \a params).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glTexParameteriv.xml}{glTexParameteriv()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
+
+    Convenience function that calls glTexSubImage2D(\a target, \a level, \a xoffset, \a yoffset, \a width, \a height, \a format, \a type, \a pixels).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glTexSubImage2D.xml}{glTexSubImage2D()}.
+
+    \since 5.3
+*/
+
+/*!
+    \fn void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+
+    Convenience function that calls glViewport(\a x, \a y, \a width, \a height).
+
+    For more information, see the OpenGL/ES 2.0 documentation for
+    \l{http://www.khronos.org/opengles/sdk/docs/man/glViewport.xml}{glViewport()}.
+
+    \since 5.3
+*/
+
+/*!
     \fn void QOpenGLFunctions::glActiveTexture(GLenum texture)
 
     Convenience function that calls glActiveTexture(\a texture).
@@ -2407,6 +2906,53 @@ QOpenGLFunctionsPrivate::QOpenGLFunctionsPrivate(QOpenGLContext *)
      * context, assigns it to the member variable and executes it
      * (see Resolver template) */
 #ifndef QT_OPENGL_ES_2
+    // OpenGL1 functions do not need resolving for now since QtGui links to libGL, libGLESv2 or opengl32.
+    BindTexture = ::glBindTexture;
+    BlendFunc = ::glBlendFunc;
+    Clear = ::glClear;
+    ClearColor = ::glClearColor;
+    ClearStencil = ::glClearStencil;
+    ColorMask = ::glColorMask;
+    CopyTexImage2D = ::glCopyTexImage2D;
+    CopyTexSubImage2D = ::glCopyTexSubImage2D;
+    CullFace = ::glCullFace;
+    DeleteTextures = ::glDeleteTextures;
+    DepthFunc = ::glDepthFunc;
+    DepthMask = ::glDepthMask;
+    Disable = ::glDisable;
+    DrawArrays = ::glDrawArrays;
+    DrawElements = ::glDrawElements;
+    Enable = ::glEnable;
+    Finish = ::glFinish;
+    Flush = ::glFlush;
+    FrontFace = ::glFrontFace;
+    GenTextures = ::glGenTextures;
+    GetBooleanv = ::glGetBooleanv;
+    GetError = ::glGetError;
+    GetFloatv = ::glGetFloatv;
+    GetIntegerv = ::glGetIntegerv;
+    GetString = ::glGetString;
+    GetTexParameterfv = ::glGetTexParameterfv;
+    GetTexParameteriv = ::glGetTexParameteriv;
+    Hint = ::glHint;
+    IsEnabled = ::glIsEnabled;
+    IsTexture = ::glIsTexture;
+    LineWidth = ::glLineWidth;
+    PixelStorei = ::glPixelStorei;
+    PolygonOffset = ::glPolygonOffset;
+    ReadPixels = ::glReadPixels;
+    Scissor = ::glScissor;
+    StencilFunc = ::glStencilFunc;
+    StencilMask = ::glStencilMask;
+    StencilOp = ::glStencilOp;
+    TexImage2D = ::glTexImage2D;
+    TexParameterf = ::glTexParameterf;
+    TexParameterfv = ::glTexParameterfv;
+    TexParameteri = ::glTexParameteri;
+    TexParameteriv = ::glTexParameteriv;
+    TexSubImage2D = ::glTexSubImage2D;
+    Viewport = ::glViewport;
+
     ActiveTexture = qopenglfResolveActiveTexture;
     AttachShader = qopenglfResolveAttachShader;
     BindAttribLocation = qopenglfResolveBindAttribLocation;
diff --git a/src/gui/opengl/qopenglfunctions.h b/src/gui/opengl/qopenglfunctions.h
index 8b84a460a3..ac49037260 100644
--- a/src/gui/opengl/qopenglfunctions.h
+++ b/src/gui/opengl/qopenglfunctions.h
@@ -79,6 +79,52 @@ struct QOpenGLFunctionsPrivate;
 
 // Undefine any macros from GLEW, qopenglextensions_p.h, etc that
 // may interfere with the definition of QOpenGLFunctions.
+#undef glBindTexture
+#undef glBlendFunc
+#undef glClear
+#undef glClearColor
+#undef glClearStencil
+#undef glColorMask
+#undef glCopyTexImage2D
+#undef glCopyTexSubImage2D
+#undef glCullFace
+#undef glDeleteTextures
+#undef glDepthFunc
+#undef glDepthMask
+#undef glDisable
+#undef glDrawArrays
+#undef glDrawElements
+#undef glEnable
+#undef glFinish
+#undef glFlush
+#undef glFrontFace
+#undef glGenTextures
+#undef glGetBooleanv
+#undef glGetError
+#undef glGetFloatv
+#undef glGetIntegerv
+#undef glGetString
+#undef glGetTexParameterfv
+#undef glGetTexParameteriv
+#undef glHint
+#undef glIsEnabled
+#undef glIsTexture
+#undef glLineWidth
+#undef glPixelStorei
+#undef glPolygonOffset
+#undef glReadPixels
+#undef glScissor
+#undef glStencilFunc
+#undef glStencilMask
+#undef glStencilOp
+#undef glTexImage2D
+#undef glTexParameterf
+#undef glTexParameterfv
+#undef glTexParameteri
+#undef glTexParameteriv
+#undef glTexSubImage2D
+#undef glViewport
+
 #undef glActiveTexture
 #undef glAttachShader
 #undef glBindAttribLocation
@@ -213,6 +259,54 @@ public:
     QT_DEPRECATED void initializeGLFunctions() { initializeOpenGLFunctions(); }
 #endif
 
+    // GLES2 + OpenGL1 common subset
+    void glBindTexture(GLenum target, GLuint texture);
+    void glBlendFunc(GLenum sfactor, GLenum dfactor);
+    void glClear(GLbitfield mask);
+    void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+    void glClearStencil(GLint s);
+    void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+    void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+    void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+    void glCullFace(GLenum mode);
+    void glDeleteTextures(GLsizei n, const GLuint* textures);
+    void glDepthFunc(GLenum func);
+    void glDepthMask(GLboolean flag);
+    void glDisable(GLenum cap);
+    void glDrawArrays(GLenum mode, GLint first, GLsizei count);
+    void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
+    void glEnable(GLenum cap);
+    void glFinish();
+    void glFlush();
+    void glFrontFace(GLenum mode);
+    void glGenTextures(GLsizei n, GLuint* textures);
+    void glGetBooleanv(GLenum pname, GLboolean* params);
+    GLenum glGetError();
+    void glGetFloatv(GLenum pname, GLfloat* params);
+    void glGetIntegerv(GLenum pname, GLint* params);
+    const GLubyte *glGetString(GLenum name);
+    void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params);
+    void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params);
+    void glHint(GLenum target, GLenum mode);
+    GLboolean glIsEnabled(GLenum cap);
+    GLboolean glIsTexture(GLuint texture);
+    void glLineWidth(GLfloat width);
+    void glPixelStorei(GLenum pname, GLint param);
+    void glPolygonOffset(GLfloat factor, GLfloat units);
+    void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
+    void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
+    void glStencilFunc(GLenum func, GLint ref, GLuint mask);
+    void glStencilMask(GLuint mask);
+    void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+    void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
+    void glTexParameterf(GLenum target, GLenum pname, GLfloat param);
+    void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
+    void glTexParameteri(GLenum target, GLenum pname, GLint param);
+    void glTexParameteriv(GLenum target, GLenum pname, const GLint* params);
+    void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
+    void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+
+    // GL(ES)2
     void glActiveTexture(GLenum texture);
     void glAttachShader(GLuint program, GLuint shader);
     void glBindAttribLocation(GLuint program, GLuint index, const char* name);
@@ -322,6 +416,52 @@ struct QOpenGLFunctionsPrivate
 {
     QOpenGLFunctionsPrivate(QOpenGLContext *ctx);
 
+    void (QOPENGLF_APIENTRYP BindTexture)(GLenum target, GLuint texture);
+    void (QOPENGLF_APIENTRYP BlendFunc)(GLenum sfactor, GLenum dfactor);
+    void (QOPENGLF_APIENTRYP Clear)(GLbitfield mask);
+    void (QOPENGLF_APIENTRYP ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+    void (QOPENGLF_APIENTRYP ClearStencil)(GLint s);
+    void (QOPENGLF_APIENTRYP ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+    void (QOPENGLF_APIENTRYP CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+    void (QOPENGLF_APIENTRYP CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+    void (QOPENGLF_APIENTRYP CullFace)(GLenum mode);
+    void (QOPENGLF_APIENTRYP DeleteTextures)(GLsizei n, const GLuint* textures);
+    void (QOPENGLF_APIENTRYP DepthFunc)(GLenum func);
+    void (QOPENGLF_APIENTRYP DepthMask)(GLboolean flag);
+    void (QOPENGLF_APIENTRYP Disable)(GLenum cap);
+    void (QOPENGLF_APIENTRYP DrawArrays)(GLenum mode, GLint first, GLsizei count);
+    void (QOPENGLF_APIENTRYP DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
+    void (QOPENGLF_APIENTRYP Enable)(GLenum cap);
+    void (QOPENGLF_APIENTRYP Finish)();
+    void (QOPENGLF_APIENTRYP Flush)();
+    void (QOPENGLF_APIENTRYP FrontFace)(GLenum mode);
+    void (QOPENGLF_APIENTRYP GenTextures)(GLsizei n, GLuint* textures);
+    void (QOPENGLF_APIENTRYP GetBooleanv)(GLenum pname, GLboolean* params);
+    GLenum (QOPENGLF_APIENTRYP GetError)();
+    void (QOPENGLF_APIENTRYP GetFloatv)(GLenum pname, GLfloat* params);
+    void (QOPENGLF_APIENTRYP GetIntegerv)(GLenum pname, GLint* params);
+    const GLubyte * (QOPENGLF_APIENTRYP GetString)(GLenum name);
+    void (QOPENGLF_APIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params);
+    void (QOPENGLF_APIENTRYP GetTexParameteriv)(GLenum target, GLenum pname, GLint* params);
+    void (QOPENGLF_APIENTRYP Hint)(GLenum target, GLenum mode);
+    GLboolean (QOPENGLF_APIENTRYP IsEnabled)(GLenum cap);
+    GLboolean (QOPENGLF_APIENTRYP IsTexture)(GLuint texture);
+    void (QOPENGLF_APIENTRYP LineWidth)(GLfloat width);
+    void (QOPENGLF_APIENTRYP PixelStorei)(GLenum pname, GLint param);
+    void (QOPENGLF_APIENTRYP PolygonOffset)(GLfloat factor, GLfloat units);
+    void (QOPENGLF_APIENTRYP ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
+    void (QOPENGLF_APIENTRYP Scissor)(GLint x, GLint y, GLsizei width, GLsizei height);
+    void (QOPENGLF_APIENTRYP StencilFunc)(GLenum func, GLint ref, GLuint mask);
+    void (QOPENGLF_APIENTRYP StencilMask)(GLuint mask);
+    void (QOPENGLF_APIENTRYP StencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
+    void (QOPENGLF_APIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
+    void (QOPENGLF_APIENTRYP TexParameterf)(GLenum target, GLenum pname, GLfloat param);
+    void (QOPENGLF_APIENTRYP TexParameterfv)(GLenum target, GLenum pname, const GLfloat* params);
+    void (QOPENGLF_APIENTRYP TexParameteri)(GLenum target, GLenum pname, GLint param);
+    void (QOPENGLF_APIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint* params);
+    void (QOPENGLF_APIENTRYP TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
+    void (QOPENGLF_APIENTRYP Viewport)(GLint x, GLint y, GLsizei width, GLsizei height);
+
     void (QOPENGLF_APIENTRYP ActiveTexture)(GLenum texture);
     void (QOPENGLF_APIENTRYP AttachShader)(GLuint program, GLuint shader);
     void (QOPENGLF_APIENTRYP BindAttribLocation)(GLuint program, GLuint index, const char* name);
@@ -419,9 +559,511 @@ struct QOpenGLFunctionsPrivate
     void (QOPENGLF_APIENTRYP VertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
 };
 
+// GLES2 + OpenGL1 common subset
+
+inline void QOpenGLFunctions::glBindTexture(GLenum target, GLuint texture)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glBindTexture(target, texture);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->BindTexture(target, texture);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glBlendFunc(sfactor, dfactor);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->BlendFunc(sfactor, dfactor);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glClear(GLbitfield mask)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glClear(mask);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Clear(mask);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glClearColor(red, green, blue, alpha);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->ClearColor(red, green, blue, alpha);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glClearStencil(GLint s)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glClearStencil(s);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->ClearStencil(s);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glColorMask(red, green, blue, alpha);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->ColorMask(red, green, blue, alpha);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glCopyTexImage2D(target, level, internalformat, x, y, width,height, border);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->CopyTexImage2D(target, level, internalformat, x, y, width,height, border);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glCullFace(GLenum mode)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glCullFace(mode);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->CullFace(mode);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glDeleteTextures(GLsizei n, const GLuint* textures)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glDeleteTextures(n, textures);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->DeleteTextures(n, textures);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glDepthFunc(GLenum func)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glDepthFunc(func);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->DepthFunc(func);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glDepthMask(GLboolean flag)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glDepthMask(flag);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->DepthMask(flag);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glDisable(GLenum cap)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glDisable(cap);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Disable(cap);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glDrawArrays(mode, first, count);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->DrawArrays(mode, first, count);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glDrawElements(mode, count, type, indices);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->DrawElements(mode, count, type, indices);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glEnable(GLenum cap)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glEnable(cap);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Enable(cap);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glFinish()
+{
+#ifdef QT_OPENGL_ES_2
+    ::glFinish();
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Finish();
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glFlush()
+{
+#ifdef QT_OPENGL_ES_2
+    ::glFlush();
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Flush();
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glFrontFace(GLenum mode)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glFrontFace(mode);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->FrontFace(mode);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glGenTextures(GLsizei n, GLuint* textures)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glGenTextures(n, textures);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->GenTextures(n, textures);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glGetBooleanv(GLenum pname, GLboolean* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glGetBooleanv(pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->GetBooleanv(pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline GLenum QOpenGLFunctions::glGetError()
+{
+#ifdef QT_OPENGL_ES_2
+    GLenum result = ::glGetError();
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    GLenum result = d_ptr->GetError();
+#endif
+    return result;
+}
+
+inline void QOpenGLFunctions::glGetFloatv(GLenum pname, GLfloat* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glGetFloatv(pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->GetFloatv(pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glGetIntegerv(GLenum pname, GLint* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glGetIntegerv(pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->GetIntegerv(pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline const GLubyte *QOpenGLFunctions::glGetString(GLenum name)
+{
+#ifdef QT_OPENGL_ES_2
+    const GLubyte *result = ::glGetString(name);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    const GLubyte *result = d_ptr->GetString(name);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+    return result;
+}
+
+inline void QOpenGLFunctions::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glGetTexParameterfv(target, pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->GetTexParameterfv(target, pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glGetTexParameteriv(target, pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->GetTexParameteriv(target, pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glHint(GLenum target, GLenum mode)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glHint(target, mode);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Hint(target, mode);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline GLboolean QOpenGLFunctions::glIsEnabled(GLenum cap)
+{
+#ifdef QT_OPENGL_ES_2
+    GLboolean result = ::glIsEnabled(cap);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    GLboolean result = d_ptr->IsEnabled(cap);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+    return result;
+}
+
+inline GLboolean QOpenGLFunctions::glIsTexture(GLuint texture)
+{
+#ifdef QT_OPENGL_ES_2
+    GLboolean result = ::glIsTexture(texture);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    GLboolean result = d_ptr->IsTexture(texture);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+    return result;
+}
+
+inline void QOpenGLFunctions::glLineWidth(GLfloat width)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glLineWidth(width);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->LineWidth(width);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glPixelStorei(GLenum pname, GLint param)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glPixelStorei(pname, param);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->PixelStorei(pname, param);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glPolygonOffset(GLfloat factor, GLfloat units)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glPolygonOffset(factor, units);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->PolygonOffset(factor, units);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glReadPixels(x, y, width, height, format, type, pixels);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->ReadPixels(x, y, width, height, format, type, pixels);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glScissor(x, y, width, height);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Scissor(x, y, width, height);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glStencilFunc(func, ref, mask);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->StencilFunc(func, ref, mask);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glStencilMask(GLuint mask)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glStencilMask(mask);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->StencilMask(mask);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glStencilOp(fail, zfail, zpass);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->StencilOp(fail, zfail, zpass);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glTexImage2D(target, level, internalformat, width,height, border, format, type, pixels);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->TexImage2D(target, level, internalformat, width,height, border, format, type, pixels);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glTexParameterf(target, pname, param);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->TexParameterf(target, pname, param);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glTexParameterfv(target, pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->TexParameterfv(target, pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glTexParameteri(target, pname, param);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->TexParameteri(target, pname, param);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glTexParameteriv(target, pname, params);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->TexParameteriv(target, pname, params);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+inline void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+#ifdef QT_OPENGL_ES_2
+    ::glViewport(x, y, width, height);
+#else
+    Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+    d_ptr->Viewport(x, y, width, height);
+#endif
+    Q_OPENGL_FUNCTIONS_DEBUG
+}
+
+// GL(ES)2
+
 inline void QOpenGLFunctions::glActiveTexture(GLenum texture)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glActiveTexture(texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -432,7 +1074,7 @@ inline void QOpenGLFunctions::glActiveTexture(GLenum texture)
 
 inline void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glAttachShader(program, shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -443,7 +1085,7 @@ inline void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)
 
 inline void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBindAttribLocation(program, index, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -454,7 +1096,7 @@ inline void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index,
 
 inline void QOpenGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBindBuffer(target, buffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -467,7 +1109,7 @@ inline void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffe
 {
     if (framebuffer == 0)
         framebuffer = QOpenGLContext::currentContext()->defaultFramebufferObject();
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBindFramebuffer(target, framebuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -478,7 +1120,7 @@ inline void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffe
 
 inline void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBindRenderbuffer(target, renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -489,7 +1131,7 @@ inline void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuf
 
 inline void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBlendColor(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -500,7 +1142,7 @@ inline void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclamp
 
 inline void QOpenGLFunctions::glBlendEquation(GLenum mode)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBlendEquation(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -511,7 +1153,7 @@ inline void QOpenGLFunctions::glBlendEquation(GLenum mode)
 
 inline void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBlendEquationSeparate(modeRGB, modeAlpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -522,7 +1164,7 @@ inline void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum mod
 
 inline void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -533,7 +1175,7 @@ inline void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
 
 inline void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBufferData(target, size, data, usage);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -544,7 +1186,7 @@ inline void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr siz
 
 inline void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glBufferSubData(target, offset, size, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -555,7 +1197,7 @@ inline void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr of
 
 inline GLenum QOpenGLFunctions::glCheckFramebufferStatus(GLenum target)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLenum result = ::glCheckFramebufferStatus(target);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -577,7 +1219,7 @@ inline void QOpenGLFunctions::glClearDepthf(GLclampf depth)
 
 inline void QOpenGLFunctions::glCompileShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glCompileShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -588,7 +1230,7 @@ inline void QOpenGLFunctions::glCompileShader(GLuint shader)
 
 inline void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -599,7 +1241,7 @@ inline void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level,
 
 inline void QOpenGLFunctions::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)
+#ifdef QT_OPENGL_ES_2
     ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -610,7 +1252,7 @@ inline void QOpenGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint lev
 
 inline GLuint QOpenGLFunctions::glCreateProgram()
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLuint result = ::glCreateProgram();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -622,7 +1264,7 @@ inline GLuint QOpenGLFunctions::glCreateProgram()
 
 inline GLuint QOpenGLFunctions::glCreateShader(GLenum type)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLuint result = ::glCreateShader(type);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -634,7 +1276,7 @@ inline GLuint QOpenGLFunctions::glCreateShader(GLenum type)
 
 inline void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDeleteBuffers(n, buffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -645,7 +1287,7 @@ inline void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
 
 inline void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDeleteFramebuffers(n, framebuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -656,7 +1298,7 @@ inline void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* fram
 
 inline void QOpenGLFunctions::glDeleteProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDeleteProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -667,7 +1309,7 @@ inline void QOpenGLFunctions::glDeleteProgram(GLuint program)
 
 inline void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDeleteRenderbuffers(n, renderbuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -678,7 +1320,7 @@ inline void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* ren
 
 inline void QOpenGLFunctions::glDeleteShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDeleteShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -699,7 +1341,7 @@ inline void QOpenGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
 
 inline void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDetachShader(program, shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -710,7 +1352,7 @@ inline void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)
 
 inline void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glDisableVertexAttribArray(index);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -721,7 +1363,7 @@ inline void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)
 
 inline void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glEnableVertexAttribArray(index);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -732,7 +1374,7 @@ inline void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)
 
 inline void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -743,7 +1385,7 @@ inline void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum at
 
 inline void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -754,7 +1396,7 @@ inline void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attac
 
 inline void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGenBuffers(n, buffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -765,7 +1407,7 @@ inline void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
 
 inline void QOpenGLFunctions::glGenerateMipmap(GLenum target)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGenerateMipmap(target);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -776,7 +1418,7 @@ inline void QOpenGLFunctions::glGenerateMipmap(GLenum target)
 
 inline void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGenFramebuffers(n, framebuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -787,7 +1429,7 @@ inline void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
 
 inline void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGenRenderbuffers(n, renderbuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -798,7 +1440,7 @@ inline void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffer
 
 inline void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -809,7 +1451,7 @@ inline void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GL
 
 inline void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -820,7 +1462,7 @@ inline void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, G
 
 inline void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetAttachedShaders(program, maxcount, count, shaders);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -831,7 +1473,7 @@ inline void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxco
 
 inline GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char* name)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLint result = ::glGetAttribLocation(program, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -843,7 +1485,7 @@ inline GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char* n
 
 inline void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetBufferParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -854,7 +1496,7 @@ inline void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname
 
 inline void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -865,7 +1507,7 @@ inline void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum targe
 
 inline void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetProgramiv(program, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -876,7 +1518,7 @@ inline void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint
 
 inline void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetProgramInfoLog(program, bufsize, length, infolog);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -887,7 +1529,7 @@ inline void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsiz
 
 inline void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetRenderbufferParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -898,7 +1540,7 @@ inline void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum
 
 inline void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetShaderiv(shader, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -909,7 +1551,7 @@ inline void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint*
 
 inline void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetShaderInfoLog(shader, bufsize, length, infolog);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -920,7 +1562,7 @@ inline void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize,
 
 inline void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -931,7 +1573,7 @@ inline void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLen
 
 inline void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetShaderSource(shader, bufsize, length, source);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -942,7 +1584,7 @@ inline void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize,
 
 inline void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetUniformfv(program, location, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -953,7 +1595,7 @@ inline void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLf
 
 inline void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetUniformiv(program, location, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -964,7 +1606,7 @@ inline void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLi
 
 inline GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char* name)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLint result = ::glGetUniformLocation(program, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -976,7 +1618,7 @@ inline GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char*
 
 inline void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetVertexAttribfv(index, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -987,7 +1629,7 @@ inline void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GL
 
 inline void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetVertexAttribiv(index, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -998,7 +1640,7 @@ inline void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GL
 
 inline void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glGetVertexAttribPointerv(index, pname, pointer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1009,7 +1651,7 @@ inline void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pna
 
 inline GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLboolean result = ::glIsBuffer(buffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1021,7 +1663,7 @@ inline GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)
 
 inline GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLboolean result = ::glIsFramebuffer(framebuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1033,7 +1675,7 @@ inline GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)
 
 inline GLboolean QOpenGLFunctions::glIsProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLboolean result = ::glIsProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1045,7 +1687,7 @@ inline GLboolean QOpenGLFunctions::glIsProgram(GLuint program)
 
 inline GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLboolean result = ::glIsRenderbuffer(renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1057,7 +1699,7 @@ inline GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
 
 inline GLboolean QOpenGLFunctions::glIsShader(GLuint shader)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     GLboolean result = ::glIsShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1069,7 +1711,7 @@ inline GLboolean QOpenGLFunctions::glIsShader(GLuint shader)
 
 inline void QOpenGLFunctions::glLinkProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glLinkProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1080,7 +1722,7 @@ inline void QOpenGLFunctions::glLinkProgram(GLuint program)
 
 inline void QOpenGLFunctions::glReleaseShaderCompiler()
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glReleaseShaderCompiler();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1091,7 +1733,7 @@ inline void QOpenGLFunctions::glReleaseShaderCompiler()
 
 inline void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glRenderbufferStorage(target, internalformat, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1102,7 +1744,7 @@ inline void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum intern
 
 inline void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glSampleCoverage(value, invert);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1113,7 +1755,7 @@ inline void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
 
 inline void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glShaderBinary(n, shaders, binaryformat, binary, length);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1124,7 +1766,7 @@ inline void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLe
 
 inline void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glShaderSource(shader, count, string, length);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1135,7 +1777,7 @@ inline void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const
 
 inline void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glStencilFuncSeparate(face, func, ref, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1146,7 +1788,7 @@ inline void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GL
 
 inline void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glStencilMaskSeparate(face, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1157,7 +1799,7 @@ inline void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
 
 inline void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glStencilOpSeparate(face, fail, zfail, zpass);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1168,7 +1810,7 @@ inline void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLen
 
 inline void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform1f(location, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1179,7 +1821,7 @@ inline void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)
 
 inline void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform1fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1190,7 +1832,7 @@ inline void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform1i(GLint location, GLint x)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform1i(location, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1201,7 +1843,7 @@ inline void QOpenGLFunctions::glUniform1i(GLint location, GLint x)
 
 inline void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform1iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1212,7 +1854,7 @@ inline void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform2f(location, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1223,7 +1865,7 @@ inline void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
 
 inline void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform2fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1234,7 +1876,7 @@ inline void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform2i(location, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1245,7 +1887,7 @@ inline void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
 
 inline void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform2iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1256,7 +1898,7 @@ inline void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform3f(location, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1267,7 +1909,7 @@ inline void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y,
 
 inline void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform3fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1278,7 +1920,7 @@ inline void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform3i(location, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1289,7 +1931,7 @@ inline void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLin
 
 inline void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform3iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1300,7 +1942,7 @@ inline void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform4f(location, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1311,7 +1953,7 @@ inline void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y,
 
 inline void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform4fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1322,7 +1964,7 @@ inline void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform4i(location, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1333,7 +1975,7 @@ inline void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLin
 
 inline void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint* v)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniform4iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1344,7 +1986,7 @@ inline void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const
 
 inline void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniformMatrix2fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1355,7 +1997,7 @@ inline void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count,
 
 inline void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniformMatrix3fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1366,7 +2008,7 @@ inline void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count,
 
 inline void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUniformMatrix4fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1377,7 +2019,7 @@ inline void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count,
 
 inline void QOpenGLFunctions::glUseProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glUseProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1388,7 +2030,7 @@ inline void QOpenGLFunctions::glUseProgram(GLuint program)
 
 inline void QOpenGLFunctions::glValidateProgram(GLuint program)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glValidateProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1399,7 +2041,7 @@ inline void QOpenGLFunctions::glValidateProgram(GLuint program)
 
 inline void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib1f(indx, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1410,7 +2052,7 @@ inline void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
 
 inline void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib1fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1421,7 +2063,7 @@ inline void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib2f(indx, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1432,7 +2074,7 @@ inline void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y
 
 inline void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib2fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1443,7 +2085,7 @@ inline void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib3f(indx, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1454,7 +2096,7 @@ inline void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y
 
 inline void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib3fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1465,7 +2107,7 @@ inline void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib4f(indx, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1476,7 +2118,7 @@ inline void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y
 
 inline void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttrib4fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
@@ -1487,7 +2129,7 @@ inline void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* valu
 
 inline void QOpenGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
 {
-#if defined(QT_OPENGL_ES_2)
+#ifdef QT_OPENGL_ES_2
     ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));