[SCM] qtbase packaging branch, master, updated. debian/5.7.1+dfsg-3-3-g38246c1
Lisandro Damián Nicanor Pérez
lisandro at moszumanska.debian.org
Sun Jul 2 23:08:51 UTC 2017
Gitweb-URL: http://git.debian.org/?p=pkg-kde/qt/qtbase.git;a=commitdiff;h=db58e42
The following commit has been merged in the master branch:
commit db58e42c64b7fd2279479e0ac478bbfa74716174
Author: Lisandro Damián Nicanor Pérez Meyer <perezmeyer at gmail.com>
Date: Thu Jun 29 19:37:39 2017 -0300
Backport patch to remove OpenGL ES 2.0 direct calls.
Closes: #866506.
---
debian/changelog | 3 +
.../remove_opengles20_direct_function_calls.patch | 1597 ++++++++++++++++++++
debian/patches/series | 1 +
3 files changed, 1601 insertions(+)
diff --git a/debian/changelog b/debian/changelog
index 0831282..1ae25fa 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,8 @@
qtbase-opensource-src (5.7.1+dfsg-4) UNRELEASED; urgency=medium
+ [ Lisandro Damián Nicanor Pérez Meyer ]
+ * Backport patch to remove OpenGL ES 2.0 direct calls (Closes: #866506).
+
-- Debian Qt/KDE Maintainers <debian-qt-kde at lists.debian.org> Thu, 29 Jun 2017 19:27:23 -0300
qtbase-opensource-src (5.7.1+dfsg-3) unstable; urgency=medium
diff --git a/debian/patches/remove_opengles20_direct_function_calls.patch b/debian/patches/remove_opengles20_direct_function_calls.patch
new file mode 100644
index 0000000..be2a243
--- /dev/null
+++ b/debian/patches/remove_opengles20_direct_function_calls.patch
@@ -0,0 +1,1597 @@
+commit 7e393280e4d073930f5dd45881b68f4afbcab84e
+Author: Jesus Fernandez <jesus.fernandez at qt.io>
+Date: Thu Oct 27 11:59:53 2016 +0200
+
+ OpenGLES20 direct function call removed
+
+ Usage of custom OpenGL functions is allowed in OpenGL ES 2. It allows
+ custom platform plugins to define their OpenGL functions.
+
+ Change-Id: I611b6987dc35deb4cf147684456f25b29f136560
+ Reviewed-by: Andy Nichols <andy.nichols at qt.io>
+
+diff --git a/src/gui/opengl/qopenglfunctions.h b/src/gui/opengl/qopenglfunctions.h
+index aad48571b3..f1a717f659 100644
+--- a/src/gui/opengl/qopenglfunctions.h
++++ b/src/gui/opengl/qopenglfunctions.h
+@@ -591,499 +591,319 @@ struct QOpenGLFunctionsPrivate
+
+ 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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.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->f.Viewport(x, y, width, height);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+@@ -1091,45 +911,29 @@ inline void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsize
+
+ inline void QOpenGLFunctions::glActiveTexture(GLenum texture)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glActiveTexture(texture);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.ActiveTexture(texture);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glAttachShader(program, shader);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.AttachShader(program, shader);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBindAttribLocation(program, index, name);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BindAttribLocation(program, index, name);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBindBuffer(target, buffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BindBuffer(target, buffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+@@ -1137,1034 +941,662 @@ inline void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffe
+ {
+ if (framebuffer == 0)
+ framebuffer = QOpenGLContext::currentContext()->defaultFramebufferObject();
+-#ifdef QT_OPENGL_ES_2
+- ::glBindFramebuffer(target, framebuffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BindFramebuffer(target, framebuffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBindRenderbuffer(target, renderbuffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BindRenderbuffer(target, renderbuffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBlendColor(red, green, blue, alpha);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BlendColor(red, green, blue, alpha);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBlendEquation(GLenum mode)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBlendEquation(mode);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BlendEquation(mode);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBlendEquationSeparate(modeRGB, modeAlpha);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BlendEquationSeparate(modeRGB, modeAlpha);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBufferData(target, size, data, usage);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BufferData(target, size, data, usage);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glBufferSubData(target, offset, size, data);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.BufferSubData(target, offset, size, data);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline GLenum QOpenGLFunctions::glCheckFramebufferStatus(GLenum target)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLenum result = ::glCheckFramebufferStatus(target);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLenum result = d_ptr->f.CheckFramebufferStatus(target);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline void QOpenGLFunctions::glClearDepthf(GLclampf depth)
+ {
+-#ifndef QT_OPENGL_ES
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.ClearDepthf(depth);
+-#else
+- ::glClearDepthf(depth);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glCompileShader(GLuint shader)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glCompileShader(shader);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.CompileShader(shader);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline GLuint QOpenGLFunctions::glCreateProgram()
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLuint result = ::glCreateProgram();
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLuint result = d_ptr->f.CreateProgram();
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline GLuint QOpenGLFunctions::glCreateShader(GLenum type)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLuint result = ::glCreateShader(type);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLuint result = d_ptr->f.CreateShader(type);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDeleteBuffers(n, buffers);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DeleteBuffers(n, buffers);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDeleteFramebuffers(n, framebuffers);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DeleteFramebuffers(n, framebuffers);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDeleteProgram(GLuint program)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDeleteProgram(program);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DeleteProgram(program);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDeleteRenderbuffers(n, renderbuffers);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DeleteRenderbuffers(n, renderbuffers);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDeleteShader(GLuint shader)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDeleteShader(shader);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DeleteShader(shader);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
+ {
+-#ifndef QT_OPENGL_ES
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DepthRangef(zNear, zFar);
+-#else
+- ::glDepthRangef(zNear, zFar);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDetachShader(program, shader);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DetachShader(program, shader);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glDisableVertexAttribArray(index);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.DisableVertexAttribArray(index);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glEnableVertexAttribArray(index);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.EnableVertexAttribArray(index);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGenBuffers(n, buffers);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GenBuffers(n, buffers);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGenerateMipmap(GLenum target)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGenerateMipmap(target);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GenerateMipmap(target);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGenFramebuffers(n, framebuffers);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GenFramebuffers(n, framebuffers);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGenRenderbuffers(n, renderbuffers);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GenRenderbuffers(n, renderbuffers);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetActiveAttrib(program, index, bufsize, length, size, type, name);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetActiveUniform(program, index, bufsize, length, size, type, name);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetAttachedShaders(program, maxcount, count, shaders);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetAttachedShaders(program, maxcount, count, shaders);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char* name)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLint result = ::glGetAttribLocation(program, name);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLint result = d_ptr->f.GetAttribLocation(program, name);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetBufferParameteriv(target, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetBufferParameteriv(target, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetProgramiv(program, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetProgramiv(program, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetProgramInfoLog(program, bufsize, length, infolog);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetProgramInfoLog(program, bufsize, length, infolog);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetRenderbufferParameteriv(target, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetRenderbufferParameteriv(target, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetShaderiv(shader, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetShaderiv(shader, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetShaderInfoLog(shader, bufsize, length, infolog);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetShaderInfoLog(shader, bufsize, length, infolog);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetShaderSource(shader, bufsize, length, source);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetShaderSource(shader, bufsize, length, source);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetUniformfv(program, location, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetUniformfv(program, location, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetUniformiv(program, location, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetUniformiv(program, location, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char* name)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLint result = ::glGetUniformLocation(program, name);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLint result = d_ptr->f.GetUniformLocation(program, name);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetVertexAttribfv(index, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetVertexAttribfv(index, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetVertexAttribiv(index, pname, params);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetVertexAttribiv(index, pname, params);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glGetVertexAttribPointerv(index, pname, pointer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.GetVertexAttribPointerv(index, pname, pointer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLboolean result = ::glIsBuffer(buffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLboolean result = d_ptr->f.IsBuffer(buffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLboolean result = ::glIsFramebuffer(framebuffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLboolean result = d_ptr->f.IsFramebuffer(framebuffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline GLboolean QOpenGLFunctions::glIsProgram(GLuint program)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLboolean result = ::glIsProgram(program);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLboolean result = d_ptr->f.IsProgram(program);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLboolean result = ::glIsRenderbuffer(renderbuffer);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLboolean result = d_ptr->f.IsRenderbuffer(renderbuffer);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline GLboolean QOpenGLFunctions::glIsShader(GLuint shader)
+ {
+-#ifdef QT_OPENGL_ES_2
+- GLboolean result = ::glIsShader(shader);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ GLboolean result = d_ptr->f.IsShader(shader);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ return result;
+ }
+
+ inline void QOpenGLFunctions::glLinkProgram(GLuint program)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glLinkProgram(program);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.LinkProgram(program);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glReleaseShaderCompiler()
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glReleaseShaderCompiler();
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.ReleaseShaderCompiler();
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glRenderbufferStorage(target, internalformat, width, height);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.RenderbufferStorage(target, internalformat, width, height);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glSampleCoverage(value, invert);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.SampleCoverage(value, invert);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glShaderBinary(n, shaders, binaryformat, binary, length);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.ShaderBinary(n, shaders, binaryformat, binary, length);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glShaderSource(shader, count, string, length);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.ShaderSource(shader, count, string, length);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glStencilFuncSeparate(face, func, ref, mask);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.StencilFuncSeparate(face, func, ref, mask);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glStencilMaskSeparate(face, mask);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.StencilMaskSeparate(face, mask);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glStencilOpSeparate(face, fail, zfail, zpass);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.StencilOpSeparate(face, fail, zfail, zpass);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform1f(location, x);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform1f(location, x);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform1fv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform1fv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform1i(GLint location, GLint x)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform1i(location, x);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform1i(location, x);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform1iv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform1iv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform2f(location, x, y);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform2f(location, x, y);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform2fv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform2fv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform2i(location, x, y);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform2i(location, x, y);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform2iv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform2iv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform3f(location, x, y, z);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform3f(location, x, y, z);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform3fv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform3fv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform3i(location, x, y, z);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform3i(location, x, y, z);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform3iv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform3iv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform4f(location, x, y, z, w);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform4f(location, x, y, z, w);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform4fv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform4fv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform4i(location, x, y, z, w);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform4i(location, x, y, z, w);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint* v)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniform4iv(location, count, v);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.Uniform4iv(location, count, v);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniformMatrix2fv(location, count, transpose, value);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.UniformMatrix2fv(location, count, transpose, value);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniformMatrix3fv(location, count, transpose, value);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.UniformMatrix3fv(location, count, transpose, value);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUniformMatrix4fv(location, count, transpose, value);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.UniformMatrix4fv(location, count, transpose, value);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glUseProgram(GLuint program)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glUseProgram(program);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.UseProgram(program);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glValidateProgram(GLuint program)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glValidateProgram(program);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.ValidateProgram(program);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib1f(indx, x);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib1f(indx, x);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib1fv(indx, values);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib1fv(indx, values);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib2f(indx, x, y);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib2f(indx, x, y);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib2fv(indx, values);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib2fv(indx, values);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib3f(indx, x, y, z);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib3f(indx, x, y, z);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib3fv(indx, values);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib3fv(indx, values);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib4f(indx, x, y, z, w);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib4f(indx, x, y, z, w);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttrib4fv(indx, values);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttrib4fv(indx, values);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
+ inline void QOpenGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
+ {
+-#ifdef QT_OPENGL_ES_2
+- ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+-#else
+ Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
+ d_ptr->f.VertexAttribPointer(indx, size, type, normalized, stride, ptr);
+-#endif
+ Q_OPENGL_FUNCTIONS_DEBUG
+ }
+
diff --git a/debian/patches/series b/debian/patches/series
index d51af60..f9c5281 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -6,6 +6,7 @@ gcc_6.3.diff
fix_accessibility_crash.diff
gtkdialogs_wayland.diff
stop_unloading_plugins.diff
+remove_opengles20_direct_function_calls.patch
# Debian specific.
no_dbus_dependency.diff
--
qtbase packaging
More information about the pkg-kde-commits
mailing list