http://macieira.org/~thiago/qt-5.3/QtOpenGL.diff
diff --git a/src/opengl/qglframebufferobject.h b/src/opengl/qglframebufferobject.h
index 9312a23..affa47c 100644
--- a/src/opengl/qglframebufferobject.h
+++ b/src/opengl/qglframebufferobject.h
@@ -63,17 +63,11 @@ public:
QGLFramebufferObject(const QSize &size, GLenum target = GL_TEXTURE_2D);
QGLFramebufferObject(int width, int height, GLenum target = GL_TEXTURE_2D);
-#if !defined(QT_OPENGL_ES) || defined(Q_QDOC)
- QGLFramebufferObject(const QSize &size, Attachment attachment,
- GLenum target = GL_TEXTURE_2D, GLenum internal_format = GL_RGBA8);
- QGLFramebufferObject(int width, int height, Attachment attachment,
- GLenum target = GL_TEXTURE_2D, GLenum internal_format = GL_RGBA8);
-#else
+
QGLFramebufferObject(const QSize &size, Attachment attachment,
- GLenum target = GL_TEXTURE_2D, GLenum internal_format = GL_RGBA);
+ GLenum target = GL_TEXTURE_2D, GLenum internal_format = 0);
QGLFramebufferObject(int width, int height, Attachment attachment,
- GLenum target = GL_TEXTURE_2D, GLenum internal_format = GL_RGBA);
-#endif
+ GLenum target = GL_TEXTURE_2D, GLenum internal_format = 0);
QGLFramebufferObject(const QSize &size, const QGLFramebufferObjectFormat &format);
QGLFramebufferObject(int width, int height, const QGLFramebufferObjectFormat &format);
diff --git a/src/opengl/qglfunctions.h b/src/opengl/qglfunctions.h
index fd867d7..f822899 100644
--- a/src/opengl/qglfunctions.h
+++ b/src/opengl/qglfunctions.h
@@ -42,140 +42,14 @@
#ifndef QGLFUNCTIONS_H
#define QGLFUNCTIONS_H
-#ifdef __GLEW_H__
-#if defined(Q_CC_GNU)
-#warning qglfunctions.h is not compatible with GLEW, GLEW defines will be undefined
-#warning To use GLEW with Qt, do not include <QtOpenGL> or <QGLFunctions> after glew.h
-#endif
-#endif
-
#include <QtOpenGL/qgl.h>
#include <QtGui/qopenglcontext.h>
+#include <QtGui/qopenglfunctions.h>
QT_BEGIN_NAMESPACE
-
-// Types that aren't defined in all system's gl.h files.
-typedef ptrdiff_t qgl_GLintptr;
-typedef ptrdiff_t qgl_GLsizeiptr;
-
-#if defined(APIENTRY) && !defined(QGLF_APIENTRY)
-# define QGLF_APIENTRY APIENTRY
-#elif defined(GL_APIENTRY) && !defined(QGLF_APIENTRY)
-# define QGLF_APIENTRY GL_APIENTRY
-#endif
-
-# ifndef QGLF_APIENTRYP
-# ifdef QGLF_APIENTRY
-# define QGLF_APIENTRYP QGLF_APIENTRY *
-# else
-# define QGLF_APIENTRY
-# define QGLF_APIENTRYP *
-# endif
-# endif
-
struct QGLFunctionsPrivate;
-// Undefine any macros from GLEW, qglextensions_p.h, etc that
-// may interfere with the definition of QGLFunctions.
-#undef glActiveTexture
-#undef glAttachShader
-#undef glBindAttribLocation
-#undef glBindBuffer
-#undef glBindFramebuffer
-#undef glBindRenderbuffer
-#undef glBlendColor
-#undef glBlendEquation
-#undef glBlendEquationSeparate
-#undef glBlendFuncSeparate
-#undef glBufferData
-#undef glBufferSubData
-#undef glCheckFramebufferStatus
-#undef glClearDepthf
-#undef glCompileShader
-#undef glCompressedTexImage2D
-#undef glCompressedTexSubImage2D
-#undef glCreateProgram
-#undef glCreateShader
-#undef glDeleteBuffers
-#undef glDeleteFramebuffers
-#undef glDeleteProgram
-#undef glDeleteRenderbuffers
-#undef glDeleteShader
-#undef glDepthRangef
-#undef glDetachShader
-#undef glDisableVertexAttribArray
-#undef glEnableVertexAttribArray
-#undef glFramebufferRenderbuffer
-#undef glFramebufferTexture2D
-#undef glGenBuffers
-#undef glGenerateMipmap
-#undef glGenFramebuffers
-#undef glGenRenderbuffers
-#undef glGetActiveAttrib
-#undef glGetActiveUniform
-#undef glGetAttachedShaders
-#undef glGetAttribLocation
-#undef glGetBufferParameteriv
-#undef glGetFramebufferAttachmentParameteriv
-#undef glGetProgramiv
-#undef glGetProgramInfoLog
-#undef glGetRenderbufferParameteriv
-#undef glGetShaderiv
-#undef glGetShaderInfoLog
-#undef glGetShaderPrecisionFormat
-#undef glGetShaderSource
-#undef glGetUniformfv
-#undef glGetUniformiv
-#undef glGetUniformLocation
-#undef glGetVertexAttribfv
-#undef glGetVertexAttribiv
-#undef glGetVertexAttribPointerv
-#undef glIsBuffer
-#undef glIsFramebuffer
-#undef glIsProgram
-#undef glIsRenderbuffer
-#undef glIsShader
-#undef glLinkProgram
-#undef glReleaseShaderCompiler
-#undef glRenderbufferStorage
-#undef glSampleCoverage
-#undef glShaderBinary
-#undef glShaderSource
-#undef glStencilFuncSeparate
-#undef glStencilMaskSeparate
-#undef glStencilOpSeparate
-#undef glUniform1f
-#undef glUniform1fv
-#undef glUniform1i
-#undef glUniform1iv
-#undef glUniform2f
-#undef glUniform2fv
-#undef glUniform2i
-#undef glUniform2iv
-#undef glUniform3f
-#undef glUniform3fv
-#undef glUniform3i
-#undef glUniform3iv
-#undef glUniform4f
-#undef glUniform4fv
-#undef glUniform4i
-#undef glUniform4iv
-#undef glUniformMatrix2fv
-#undef glUniformMatrix3fv
-#undef glUniformMatrix4fv
-#undef glUseProgram
-#undef glValidateProgram
-#undef glVertexAttrib1f
-#undef glVertexAttrib1fv
-#undef glVertexAttrib2f
-#undef glVertexAttrib2fv
-#undef glVertexAttrib3f
-#undef glVertexAttrib3fv
-#undef glVertexAttrib4f
-#undef glVertexAttrib4fv
-#undef glVertexAttribPointer
-
class Q_OPENGL_EXPORT QGLFunctions
{
public:
@@ -216,8 +90,8 @@ public:
void glBlendEquation(GLenum mode);
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
- void glBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
- void glBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
+ void glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage);
+ void glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data);
GLenum glCheckFramebufferStatus(GLenum target);
void glClearDepthf(GLclampf depth);
void glCompileShader(GLuint shader);
@@ -314,1074 +188,591 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(QGLFunctions::OpenGLFeatures)
struct QGLFunctionsPrivate
{
QGLFunctionsPrivate(const QGLContext *context = 0);
-
-#ifndef QT_OPENGL_ES_2
- void (QGLF_APIENTRYP activeTexture)(GLenum texture);
- void (QGLF_APIENTRYP attachShader)(GLuint program, GLuint shader);
- void (QGLF_APIENTRYP bindAttribLocation)(GLuint program, GLuint index, const char* name);
- void (QGLF_APIENTRYP bindBuffer)(GLenum target, GLuint buffer);
- void (QGLF_APIENTRYP bindFramebuffer)(GLenum target, GLuint framebuffer);
- void (QGLF_APIENTRYP bindRenderbuffer)(GLenum target, GLuint renderbuffer);
- void (QGLF_APIENTRYP blendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
- void (QGLF_APIENTRYP blendEquation)(GLenum mode);
- void (QGLF_APIENTRYP blendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
- void (QGLF_APIENTRYP blendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
- void (QGLF_APIENTRYP bufferData)(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage);
- void (QGLF_APIENTRYP bufferSubData)(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data);
- GLenum (QGLF_APIENTRYP checkFramebufferStatus)(GLenum target);
- void (QGLF_APIENTRYP compileShader)(GLuint shader);
- void (QGLF_APIENTRYP compressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
- void (QGLF_APIENTRYP compressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
- GLuint (QGLF_APIENTRYP createProgram)();
- GLuint (QGLF_APIENTRYP createShader)(GLenum type);
- void (QGLF_APIENTRYP deleteBuffers)(GLsizei n, const GLuint* buffers);
- void (QGLF_APIENTRYP deleteFramebuffers)(GLsizei n, const GLuint* framebuffers);
- void (QGLF_APIENTRYP deleteProgram)(GLuint program);
- void (QGLF_APIENTRYP deleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);
- void (QGLF_APIENTRYP deleteShader)(GLuint shader);
- void (QGLF_APIENTRYP detachShader)(GLuint program, GLuint shader);
- void (QGLF_APIENTRYP disableVertexAttribArray)(GLuint index);
- void (QGLF_APIENTRYP enableVertexAttribArray)(GLuint index);
- void (QGLF_APIENTRYP framebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
- void (QGLF_APIENTRYP framebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
- void (QGLF_APIENTRYP genBuffers)(GLsizei n, GLuint* buffers);
- void (QGLF_APIENTRYP generateMipmap)(GLenum target);
- void (QGLF_APIENTRYP genFramebuffers)(GLsizei n, GLuint* framebuffers);
- void (QGLF_APIENTRYP genRenderbuffers)(GLsizei n, GLuint* renderbuffers);
- void (QGLF_APIENTRYP getActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
- void (QGLF_APIENTRYP getActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
- void (QGLF_APIENTRYP getAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
- int (QGLF_APIENTRYP getAttribLocation)(GLuint program, const char* name);
- void (QGLF_APIENTRYP getBufferParameteriv)(GLenum target, GLenum pname, GLint* params);
- void (QGLF_APIENTRYP getFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
- void (QGLF_APIENTRYP getProgramiv)(GLuint program, GLenum pname, GLint* params);
- void (QGLF_APIENTRYP getProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
- void (QGLF_APIENTRYP getRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
- void (QGLF_APIENTRYP getShaderiv)(GLuint shader, GLenum pname, GLint* params);
- void (QGLF_APIENTRYP getShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
- void (QGLF_APIENTRYP getShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
- void (QGLF_APIENTRYP getShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
- void (QGLF_APIENTRYP getUniformfv)(GLuint program, GLint location, GLfloat* params);
- void (QGLF_APIENTRYP getUniformiv)(GLuint program, GLint location, GLint* params);
- int (QGLF_APIENTRYP getUniformLocation)(GLuint program, const char* name);
- void (QGLF_APIENTRYP getVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);
- void (QGLF_APIENTRYP getVertexAttribiv)(GLuint index, GLenum pname, GLint* params);
- void (QGLF_APIENTRYP getVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);
- GLboolean (QGLF_APIENTRYP isBuffer)(GLuint buffer);
- GLboolean (QGLF_APIENTRYP isFramebuffer)(GLuint framebuffer);
- GLboolean (QGLF_APIENTRYP isProgram)(GLuint program);
- GLboolean (QGLF_APIENTRYP isRenderbuffer)(GLuint renderbuffer);
- GLboolean (QGLF_APIENTRYP isShader)(GLuint shader);
- void (QGLF_APIENTRYP linkProgram)(GLuint program);
- void (QGLF_APIENTRYP releaseShaderCompiler)();
- void (QGLF_APIENTRYP renderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
- void (QGLF_APIENTRYP sampleCoverage)(GLclampf value, GLboolean invert);
- void (QGLF_APIENTRYP shaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
- void (QGLF_APIENTRYP shaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
- void (QGLF_APIENTRYP stencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
- void (QGLF_APIENTRYP stencilMaskSeparate)(GLenum face, GLuint mask);
- void (QGLF_APIENTRYP stencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
- void (QGLF_APIENTRYP uniform1f)(GLint location, GLfloat x);
- void (QGLF_APIENTRYP uniform1fv)(GLint location, GLsizei count, const GLfloat* v);
- void (QGLF_APIENTRYP uniform1i)(GLint location, GLint x);
- void (QGLF_APIENTRYP uniform1iv)(GLint location, GLsizei count, const GLint* v);
- void (QGLF_APIENTRYP uniform2f)(GLint location, GLfloat x, GLfloat y);
- void (QGLF_APIENTRYP uniform2fv)(GLint location, GLsizei count, const GLfloat* v);
- void (QGLF_APIENTRYP uniform2i)(GLint location, GLint x, GLint y);
- void (QGLF_APIENTRYP uniform2iv)(GLint location, GLsizei count, const GLint* v);
- void (QGLF_APIENTRYP uniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);
- void (QGLF_APIENTRYP uniform3fv)(GLint location, GLsizei count, const GLfloat* v);
- void (QGLF_APIENTRYP uniform3i)(GLint location, GLint x, GLint y, GLint z);
- void (QGLF_APIENTRYP uniform3iv)(GLint location, GLsizei count, const GLint* v);
- void (QGLF_APIENTRYP uniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
- void (QGLF_APIENTRYP uniform4fv)(GLint location, GLsizei count, const GLfloat* v);
- void (QGLF_APIENTRYP uniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);
- void (QGLF_APIENTRYP uniform4iv)(GLint location, GLsizei count, const GLint* v);
- void (QGLF_APIENTRYP uniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
- void (QGLF_APIENTRYP uniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
- void (QGLF_APIENTRYP uniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
- void (QGLF_APIENTRYP useProgram)(GLuint program);
- void (QGLF_APIENTRYP validateProgram)(GLuint program);
- void (QGLF_APIENTRYP vertexAttrib1f)(GLuint indx, GLfloat x);
- void (QGLF_APIENTRYP vertexAttrib1fv)(GLuint indx, const GLfloat* values);
- void (QGLF_APIENTRYP vertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
- void (QGLF_APIENTRYP vertexAttrib2fv)(GLuint indx, const GLfloat* values);
- void (QGLF_APIENTRYP vertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
- void (QGLF_APIENTRYP vertexAttrib3fv)(GLuint indx, const GLfloat* values);
- void (QGLF_APIENTRYP vertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
- void (QGLF_APIENTRYP vertexAttrib4fv)(GLuint indx, const GLfloat* values);
- void (QGLF_APIENTRYP vertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
-#endif
+ QOpenGLFunctions *funcs;
};
inline void QGLFunctions::glActiveTexture(GLenum texture)
{
-#if defined(QT_OPENGL_ES_2)
- ::glActiveTexture(texture);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->activeTexture(texture);
-#endif
+ d_ptr->funcs->glActiveTexture(texture);
}
inline void QGLFunctions::glAttachShader(GLuint program, GLuint shader)
{
-#if defined(QT_OPENGL_ES_2)
- ::glAttachShader(program, shader);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->attachShader(program, shader);
-#endif
+ d_ptr->funcs->glAttachShader(program, shader);
}
inline void QGLFunctions::glBindAttribLocation(GLuint program, GLuint index, const char* name)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBindAttribLocation(program, index, name);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->bindAttribLocation(program, index, name);
-#endif
+ d_ptr->funcs->glBindAttribLocation(program, index, name);
}
inline void QGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBindBuffer(target, buffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->bindBuffer(target, buffer);
-#endif
+ d_ptr->funcs->glBindBuffer(target, buffer);
}
inline void QGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffer)
{
if (framebuffer == 0)
framebuffer = QOpenGLContext::currentContext()->defaultFramebufferObject();
-#if defined(QT_OPENGL_ES_2)
- ::glBindFramebuffer(target, framebuffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->bindFramebuffer(target, framebuffer);
-#endif
+ d_ptr->funcs->glBindFramebuffer(target, framebuffer);
}
inline void QGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBindRenderbuffer(target, renderbuffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->bindRenderbuffer(target, renderbuffer);
-#endif
+ d_ptr->funcs->glBindRenderbuffer(target, renderbuffer);
}
inline void QGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBlendColor(red, green, blue, alpha);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->blendColor(red, green, blue, alpha);
-#endif
+ d_ptr->funcs->glBlendColor(red, green, blue, alpha);
}
inline void QGLFunctions::glBlendEquation(GLenum mode)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBlendEquation(mode);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->blendEquation(mode);
-#endif
+ d_ptr->funcs->glBlendEquation(mode);
}
inline void QGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBlendEquationSeparate(modeRGB, modeAlpha);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->blendEquationSeparate(modeRGB, modeAlpha);
-#endif
+ d_ptr->funcs->glBlendEquationSeparate(modeRGB, modeAlpha);
}
inline void QGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-#endif
+ d_ptr->funcs->glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
-inline void QGLFunctions::glBufferData(GLenum target, qgl_GLsizeiptr size, const void* data, GLenum usage)
+inline void QGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBufferData(target, size, data, usage);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->bufferData(target, size, data, usage);
-#endif
+ d_ptr->funcs->glBufferData(target, size, data, usage);
}
-inline void QGLFunctions::glBufferSubData(GLenum target, qgl_GLintptr offset, qgl_GLsizeiptr size, const void* data)
+inline void QGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
{
-#if defined(QT_OPENGL_ES_2)
- ::glBufferSubData(target, offset, size, data);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->bufferSubData(target, offset, size, data);
-#endif
+ d_ptr->funcs->glBufferSubData(target, offset, size, data);
}
inline GLenum QGLFunctions::glCheckFramebufferStatus(GLenum target)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glCheckFramebufferStatus(target);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->checkFramebufferStatus(target);
-#endif
+ return d_ptr->funcs->glCheckFramebufferStatus(target);
}
inline void QGLFunctions::glClearDepthf(GLclampf depth)
{
-#ifndef QT_OPENGL_ES
- ::glClearDepth(depth);
-#else
- ::glClearDepthf(depth);
-#endif
+ Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
+ return d_ptr->funcs->glClearDepthf(depth);
}
inline void QGLFunctions::glCompileShader(GLuint shader)
{
-#if defined(QT_OPENGL_ES_2)
- ::glCompileShader(shader);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->compileShader(shader);
-#endif
+ d_ptr->funcs->glCompileShader(shader);
}
inline void QGLFunctions::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
{
-#if defined(QT_OPENGL_ES_2)
- ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-#endif
+ d_ptr->funcs->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}
inline void QGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
{
-#if defined(QT_OPENGL_ES_2)
- ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-#endif
+ d_ptr->funcs->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
inline GLuint QGLFunctions::glCreateProgram()
{
-#if defined(QT_OPENGL_ES_2)
- return ::glCreateProgram();
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->createProgram();
-#endif
+ return d_ptr->funcs->glCreateProgram();
}
inline GLuint QGLFunctions::glCreateShader(GLenum type)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glCreateShader(type);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->createShader(type);
-#endif
+ return d_ptr->funcs->glCreateShader(type);
}
inline void QGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDeleteBuffers(n, buffers);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->deleteBuffers(n, buffers);
-#endif
+ d_ptr->funcs->glDeleteBuffers(n, buffers);
}
inline void QGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDeleteFramebuffers(n, framebuffers);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->deleteFramebuffers(n, framebuffers);
-#endif
+ d_ptr->funcs->glDeleteFramebuffers(n, framebuffers);
}
inline void QGLFunctions::glDeleteProgram(GLuint program)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDeleteProgram(program);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->deleteProgram(program);
-#endif
+ d_ptr->funcs->glDeleteProgram(program);
}
inline void QGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDeleteRenderbuffers(n, renderbuffers);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->deleteRenderbuffers(n, renderbuffers);
-#endif
+ d_ptr->funcs->glDeleteRenderbuffers(n, renderbuffers);
}
inline void QGLFunctions::glDeleteShader(GLuint shader)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDeleteShader(shader);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->deleteShader(shader);
-#endif
+ d_ptr->funcs->glDeleteShader(shader);
}
inline void QGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
{
-#ifndef QT_OPENGL_ES
- ::glDepthRange(zNear, zFar);
-#else
- ::glDepthRangef(zNear, zFar);
-#endif
+ Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
+ return d_ptr->funcs->glDepthRangef(zNear, zFar);
}
inline void QGLFunctions::glDetachShader(GLuint program, GLuint shader)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDetachShader(program, shader);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->detachShader(program, shader);
-#endif
+ d_ptr->funcs->glDetachShader(program, shader);
}
inline void QGLFunctions::glDisableVertexAttribArray(GLuint index)
{
-#if defined(QT_OPENGL_ES_2)
- ::glDisableVertexAttribArray(index);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->disableVertexAttribArray(index);
-#endif
+ d_ptr->funcs->glDisableVertexAttribArray(index);
}
inline void QGLFunctions::glEnableVertexAttribArray(GLuint index)
{
-#if defined(QT_OPENGL_ES_2)
- ::glEnableVertexAttribArray(index);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->enableVertexAttribArray(index);
-#endif
+ d_ptr->funcs->glEnableVertexAttribArray(index);
}
inline void QGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
-#if defined(QT_OPENGL_ES_2)
- ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-#endif
+ d_ptr->funcs->glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
inline void QGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
-#if defined(QT_OPENGL_ES_2)
- ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->framebufferTexture2D(target, attachment, textarget, texture, level);
-#endif
+ d_ptr->funcs->glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
inline void QGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGenBuffers(n, buffers);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->genBuffers(n, buffers);
-#endif
+ d_ptr->funcs->glGenBuffers(n, buffers);
}
inline void QGLFunctions::glGenerateMipmap(GLenum target)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGenerateMipmap(target);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->generateMipmap(target);
-#endif
+ d_ptr->funcs->glGenerateMipmap(target);
}
inline void QGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGenFramebuffers(n, framebuffers);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->genFramebuffers(n, framebuffers);
-#endif
+ d_ptr->funcs->glGenFramebuffers(n, framebuffers);
}
inline void QGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGenRenderbuffers(n, renderbuffers);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->genRenderbuffers(n, renderbuffers);
-#endif
+ d_ptr->funcs->glGenRenderbuffers(n, renderbuffers);
}
inline void QGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getActiveAttrib(program, index, bufsize, length, size, type, name);
-#endif
+ d_ptr->funcs->glGetActiveAttrib(program, index, bufsize, length, size, type, name);
}
inline void QGLFunctions::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getActiveUniform(program, index, bufsize, length, size, type, name);
-#endif
+ d_ptr->funcs->glGetActiveUniform(program, index, bufsize, length, size, type, name);
}
inline void QGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetAttachedShaders(program, maxcount, count, shaders);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getAttachedShaders(program, maxcount, count, shaders);
-#endif
+ d_ptr->funcs->glGetAttachedShaders(program, maxcount, count, shaders);
}
inline int QGLFunctions::glGetAttribLocation(GLuint program, const char* name)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glGetAttribLocation(program, name);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->getAttribLocation(program, name);
-#endif
+ return d_ptr->funcs->glGetAttribLocation(program, name);
}
inline void QGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetBufferParameteriv(target, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getBufferParameteriv(target, pname, params);
-#endif
+ d_ptr->funcs->glGetBufferParameteriv(target, pname, params);
}
inline void QGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
-#endif
+ d_ptr->funcs->glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
inline void QGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetProgramiv(program, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getProgramiv(program, pname, params);
-#endif
+ d_ptr->funcs->glGetProgramiv(program, pname, params);
}
inline void QGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetProgramInfoLog(program, bufsize, length, infolog);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getProgramInfoLog(program, bufsize, length, infolog);
-#endif
+ d_ptr->funcs->glGetProgramInfoLog(program, bufsize, length, infolog);
}
inline void QGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetRenderbufferParameteriv(target, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getRenderbufferParameteriv(target, pname, params);
-#endif
+ d_ptr->funcs->glGetRenderbufferParameteriv(target, pname, params);
}
inline void QGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetShaderiv(shader, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getShaderiv(shader, pname, params);
-#endif
+ d_ptr->funcs->glGetShaderiv(shader, pname, params);
}
inline void QGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetShaderInfoLog(shader, bufsize, length, infolog);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getShaderInfoLog(shader, bufsize, length, infolog);
-#endif
+ d_ptr->funcs->glGetShaderInfoLog(shader, bufsize, length, infolog);
}
inline void QGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
-#endif
+ d_ptr->funcs->glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
inline void QGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetShaderSource(shader, bufsize, length, source);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getShaderSource(shader, bufsize, length, source);
-#endif
+ d_ptr->funcs->glGetShaderSource(shader, bufsize, length, source);
}
inline void QGLFunctions::glGetUniformfv(GLuint program, GLint location, GLfloat* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetUniformfv(program, location, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getUniformfv(program, location, params);
-#endif
+ d_ptr->funcs->glGetUniformfv(program, location, params);
}
inline void QGLFunctions::glGetUniformiv(GLuint program, GLint location, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetUniformiv(program, location, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getUniformiv(program, location, params);
-#endif
+ d_ptr->funcs->glGetUniformiv(program, location, params);
}
inline int QGLFunctions::glGetUniformLocation(GLuint program, const char* name)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glGetUniformLocation(program, name);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->getUniformLocation(program, name);
-#endif
+ return d_ptr->funcs->glGetUniformLocation(program, name);
}
inline void QGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetVertexAttribfv(index, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getVertexAttribfv(index, pname, params);
-#endif
+ d_ptr->funcs->glGetVertexAttribfv(index, pname, params);
}
inline void QGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetVertexAttribiv(index, pname, params);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getVertexAttribiv(index, pname, params);
-#endif
+ d_ptr->funcs->glGetVertexAttribiv(index, pname, params);
}
inline void QGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
{
-#if defined(QT_OPENGL_ES_2)
- ::glGetVertexAttribPointerv(index, pname, pointer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->getVertexAttribPointerv(index, pname, pointer);
-#endif
+ d_ptr->funcs->glGetVertexAttribPointerv(index, pname, pointer);
}
inline GLboolean QGLFunctions::glIsBuffer(GLuint buffer)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glIsBuffer(buffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->isBuffer(buffer);
-#endif
+ return d_ptr->funcs->glIsBuffer(buffer);
}
inline GLboolean QGLFunctions::glIsFramebuffer(GLuint framebuffer)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glIsFramebuffer(framebuffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->isFramebuffer(framebuffer);
-#endif
+ return d_ptr->funcs->glIsFramebuffer(framebuffer);
}
inline GLboolean QGLFunctions::glIsProgram(GLuint program)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glIsProgram(program);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->isProgram(program);
-#endif
+ return d_ptr->funcs->glIsProgram(program);
}
inline GLboolean QGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glIsRenderbuffer(renderbuffer);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->isRenderbuffer(renderbuffer);
-#endif
+ return d_ptr->funcs->glIsRenderbuffer(renderbuffer);
}
inline GLboolean QGLFunctions::glIsShader(GLuint shader)
{
-#if defined(QT_OPENGL_ES_2)
- return ::glIsShader(shader);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- return d_ptr->isShader(shader);
-#endif
+ return d_ptr->funcs->glIsShader(shader);
}
inline void QGLFunctions::glLinkProgram(GLuint program)
{
-#if defined(QT_OPENGL_ES_2)
- ::glLinkProgram(program);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->linkProgram(program);
-#endif
+ d_ptr->funcs->glLinkProgram(program);
}
inline void QGLFunctions::glReleaseShaderCompiler()
{
-#if defined(QT_OPENGL_ES_2)
- ::glReleaseShaderCompiler();
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->releaseShaderCompiler();
-#endif
+ d_ptr->funcs->glReleaseShaderCompiler();
}
inline void QGLFunctions::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
-#if defined(QT_OPENGL_ES_2)
- ::glRenderbufferStorage(target, internalformat, width, height);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->renderbufferStorage(target, internalformat, width, height);
-#endif
+ d_ptr->funcs->glRenderbufferStorage(target, internalformat, width, height);
}
inline void QGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
{
-#if defined(QT_OPENGL_ES_2)
- ::glSampleCoverage(value, invert);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->sampleCoverage(value, invert);
-#endif
+ d_ptr->funcs->glSampleCoverage(value, invert);
}
inline void QGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
{
-#if defined(QT_OPENGL_ES_2)
- ::glShaderBinary(n, shaders, binaryformat, binary, length);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->shaderBinary(n, shaders, binaryformat, binary, length);
-#endif
+ d_ptr->funcs->glShaderBinary(n, shaders, binaryformat, binary, length);
}
inline void QGLFunctions::glShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
{
-#if defined(QT_OPENGL_ES_2)
- ::glShaderSource(shader, count, string, length);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->shaderSource(shader, count, string, length);
-#endif
+ d_ptr->funcs->glShaderSource(shader, count, string, length);
}
inline void QGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
-#if defined(QT_OPENGL_ES_2)
- ::glStencilFuncSeparate(face, func, ref, mask);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->stencilFuncSeparate(face, func, ref, mask);
-#endif
+ d_ptr->funcs->glStencilFuncSeparate(face, func, ref, mask);
}
inline void QGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
{
-#if defined(QT_OPENGL_ES_2)
- ::glStencilMaskSeparate(face, mask);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->stencilMaskSeparate(face, mask);
-#endif
+ d_ptr->funcs->glStencilMaskSeparate(face, mask);
}
inline void QGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
{
-#if defined(QT_OPENGL_ES_2)
- ::glStencilOpSeparate(face, fail, zfail, zpass);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->stencilOpSeparate(face, fail, zfail, zpass);
-#endif
+ d_ptr->funcs->glStencilOpSeparate(face, fail, zfail, zpass);
}
inline void QGLFunctions::glUniform1f(GLint location, GLfloat x)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform1f(location, x);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform1f(location, x);
-#endif
+ d_ptr->funcs->glUniform1f(location, x);
}
inline void QGLFunctions::glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform1fv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform1fv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform1fv(location, count, v);
}
inline void QGLFunctions::glUniform1i(GLint location, GLint x)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform1i(location, x);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform1i(location, x);
-#endif
+ d_ptr->funcs->glUniform1i(location, x);
}
inline void QGLFunctions::glUniform1iv(GLint location, GLsizei count, const GLint* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform1iv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform1iv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform1iv(location, count, v);
}
inline void QGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform2f(location, x, y);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform2f(location, x, y);
-#endif
+ d_ptr->funcs->glUniform2f(location, x, y);
}
inline void QGLFunctions::glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform2fv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform2fv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform2fv(location, count, v);
}
inline void QGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform2i(location, x, y);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform2i(location, x, y);
-#endif
+ d_ptr->funcs->glUniform2i(location, x, y);
}
inline void QGLFunctions::glUniform2iv(GLint location, GLsizei count, const GLint* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform2iv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform2iv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform2iv(location, count, v);
}
inline void QGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform3f(location, x, y, z);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform3f(location, x, y, z);
-#endif
+ d_ptr->funcs->glUniform3f(location, x, y, z);
}
inline void QGLFunctions::glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform3fv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform3fv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform3fv(location, count, v);
}
inline void QGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLint z)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform3i(location, x, y, z);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform3i(location, x, y, z);
-#endif
+ d_ptr->funcs->glUniform3i(location, x, y, z);
}
inline void QGLFunctions::glUniform3iv(GLint location, GLsizei count, const GLint* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform3iv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform3iv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform3iv(location, count, v);
}
inline void QGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform4f(location, x, y, z, w);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform4f(location, x, y, z, w);
-#endif
+ d_ptr->funcs->glUniform4f(location, x, y, z, w);
}
inline void QGLFunctions::glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform4fv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform4fv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform4fv(location, count, v);
}
inline void QGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform4i(location, x, y, z, w);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform4i(location, x, y, z, w);
-#endif
+ d_ptr->funcs->glUniform4i(location, x, y, z, w);
}
inline void QGLFunctions::glUniform4iv(GLint location, GLsizei count, const GLint* v)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniform4iv(location, count, v);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniform4iv(location, count, v);
-#endif
+ d_ptr->funcs->glUniform4iv(location, count, v);
}
inline void QGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniformMatrix2fv(location, count, transpose, value);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniformMatrix2fv(location, count, transpose, value);
-#endif
+ d_ptr->funcs->glUniformMatrix2fv(location, count, transpose, value);
}
inline void QGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniformMatrix3fv(location, count, transpose, value);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniformMatrix3fv(location, count, transpose, value);
-#endif
+ d_ptr->funcs->glUniformMatrix3fv(location, count, transpose, value);
}
inline void QGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUniformMatrix4fv(location, count, transpose, value);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->uniformMatrix4fv(location, count, transpose, value);
-#endif
+ d_ptr->funcs->glUniformMatrix4fv(location, count, transpose, value);
}
inline void QGLFunctions::glUseProgram(GLuint program)
{
-#if defined(QT_OPENGL_ES_2)
- ::glUseProgram(program);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->useProgram(program);
-#endif
+ d_ptr->funcs->glUseProgram(program);
}
inline void QGLFunctions::glValidateProgram(GLuint program)
{
-#if defined(QT_OPENGL_ES_2)
- ::glValidateProgram(program);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->validateProgram(program);
-#endif
+ d_ptr->funcs->glValidateProgram(program);
}
inline void QGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib1f(indx, x);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib1f(indx, x);
-#endif
+ d_ptr->funcs->glVertexAttrib1f(indx, x);
}
inline void QGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* values)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib1fv(indx, values);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib1fv(indx, values);
-#endif
+ d_ptr->funcs->glVertexAttrib1fv(indx, values);
}
inline void QGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib2f(indx, x, y);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib2f(indx, x, y);
-#endif
+ d_ptr->funcs->glVertexAttrib2f(indx, x, y);
}
inline void QGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* values)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib2fv(indx, values);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib2fv(indx, values);
-#endif
+ d_ptr->funcs->glVertexAttrib2fv(indx, values);
}
inline void QGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib3f(indx, x, y, z);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib3f(indx, x, y, z);
-#endif
+ d_ptr->funcs->glVertexAttrib3f(indx, x, y, z);
}
inline void QGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* values)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib3fv(indx, values);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib3fv(indx, values);
-#endif
+ d_ptr->funcs->glVertexAttrib3fv(indx, values);
}
inline void QGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib4f(indx, x, y, z, w);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib4f(indx, x, y, z, w);
-#endif
+ d_ptr->funcs->glVertexAttrib4f(indx, x, y, z, w);
}
inline void QGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* values)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttrib4fv(indx, values);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttrib4fv(indx, values);
-#endif
+ d_ptr->funcs->glVertexAttrib4fv(indx, values);
}
inline void QGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
{
-#if defined(QT_OPENGL_ES_2)
- ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
-#else
Q_ASSERT(QGLFunctions::isInitialized(d_ptr));
- d_ptr->vertexAttribPointer(indx, size, type, normalized, stride, ptr);
-#endif
+ d_ptr->funcs->glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
}
#ifndef GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
_______________________________________________
Development mailing list
Development@qt-project.org
http://lists.qt-project.org/mailman/listinfo/development
