AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OpenGL: Add versioned functions support for opengl 4.4 and 4.5

Browse Source 
Previous errors in versioned function classes for OpenGL versions
prior to 4.4 have also been fixed to comply with the new OpenGL
xml specification. Such mistakes were due to either bugs in the
old plain text specification files or problems due to the
difficulty in parsing the old spec files.

In some cases this has meant adding in missing functions that were
absent previously.

The other class of problem was when functions were erroneously
included in the versioned function classes when they should not
have been present. That is, some core profile classes incorrectly
had member functions for deprecated functions that should only
be present in the compatibility profile classes. In these cases
these incorrect functions will now trigger a qFatal if
called. This is fine as any applications that called these by mistake
in the past would have been dereferencing a null pointer as the
function pointer resolution would have failed for these functions.

[ChangeLog][QtGui] Add version function classes for OpenGL 4.4 and 4.5
and deprecate some erroneously classified functions.

Task-Id: QTBUG-33671
Task-Id: QTBUG-44364
Change-Id: I224108dcaf4f8b4933bc121827511841e2a41590
Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
This commit is contained in:
David Morgan 2014-09-23 16:43:32 +01:00 committed by Sean Harmer
parent 38aafe1a17
commit 18aae36a90
42 changed files with 23484 additions and 1278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/gui/opengl/opengl.pri
View File

@ -83,12 +83,16 @@ contains(QT_CONFIG, opengl)|contains(QT_CONFIG, opengles2) {
opengl/qopenglfunctions_4_1_core.h \
opengl/qopenglfunctions_4_2_core.h \
opengl/qopenglfunctions_4_3_core.h \
opengl/qopenglfunctions_4_4_core.h \
opengl/qopenglfunctions_4_5_core.h \
opengl/qopenglfunctions_3_2_compatibility.h \
opengl/qopenglfunctions_3_3_compatibility.h \
opengl/qopenglfunctions_4_0_compatibility.h \
opengl/qopenglfunctions_4_1_compatibility.h \
opengl/qopenglfunctions_4_2_compatibility.h \
opengl/qopenglfunctions_4_3_compatibility.h \
opengl/qopenglfunctions_4_4_compatibility.h \
opengl/qopenglfunctions_4_5_compatibility.h \
opengl/qopenglqueryhelper_p.h \
opengl/qopengltimerquery.h
@ -108,12 +112,16 @@ contains(QT_CONFIG, opengl)|contains(QT_CONFIG, opengles2) {
opengl/qopenglfunctions_4_1_core.cpp \
opengl/qopenglfunctions_4_2_core.cpp \
opengl/qopenglfunctions_4_3_core.cpp \
opengl/qopenglfunctions_4_4_core.cpp \
opengl/qopenglfunctions_4_5_core.cpp \
opengl/qopenglfunctions_3_2_compatibility.cpp \
opengl/qopenglfunctions_3_3_compatibility.cpp \
opengl/qopenglfunctions_4_0_compatibility.cpp \
opengl/qopenglfunctions_4_1_compatibility.cpp \
opengl/qopenglfunctions_4_2_compatibility.cpp \
opengl/qopenglfunctions_4_3_compatibility.cpp \
opengl/qopenglfunctions_4_4_compatibility.cpp \
opengl/qopenglfunctions_4_5_compatibility.cpp \
opengl/qopengltimerquery.cpp
}

6
src/gui/opengl/qopenglfunctions_1_1.h
View File

@ -661,12 +661,12 @@ inline void QOpenGLFunctions_1_1::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_1_1::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_1_1::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_1_1::glIsTexture(GLuint texture)
@ -726,7 +726,7 @@ inline void QOpenGLFunctions_1_1::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_1_1::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_1_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

6
src/gui/opengl/qopenglfunctions_1_2.h
View File

@ -705,12 +705,12 @@ inline void QOpenGLFunctions_1_2::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_1_2::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_1_2::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_1_2::glIsTexture(GLuint texture)
@ -770,7 +770,7 @@ inline void QOpenGLFunctions_1_2::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_1_2::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_1_2::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

6
src/gui/opengl/qopenglfunctions_1_3.h
View File

@ -757,12 +757,12 @@ inline void QOpenGLFunctions_1_3::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_1_3::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_1_3::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_1_3::glIsTexture(GLuint texture)
@ -822,7 +822,7 @@ inline void QOpenGLFunctions_1_3::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_1_3::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_1_3::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

6
src/gui/opengl/qopenglfunctions_1_4.h
View File

@ -808,12 +808,12 @@ inline void QOpenGLFunctions_1_4::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_1_4::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_1_4::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_1_4::glIsTexture(GLuint texture)
@ -873,7 +873,7 @@ inline void QOpenGLFunctions_1_4::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_1_4::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_1_4::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

6
src/gui/opengl/qopenglfunctions_1_5.h
View File

@ -832,12 +832,12 @@ inline void QOpenGLFunctions_1_5::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_1_5::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_1_5::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_1_5::glIsTexture(GLuint texture)
@ -897,7 +897,7 @@ inline void QOpenGLFunctions_1_5::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_1_5::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_1_5::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

14
src/gui/opengl/qopenglfunctions_2_0.cpp
View File

@ -73,7 +73,7 @@ QOpenGLFunctions_2_0::QOpenGLFunctions_2_0()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
{
}
@ -127,10 +127,6 @@ QOpenGLFunctions_2_0::~QOpenGLFunctions_2_0()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
}
bool QOpenGLFunctions_2_0::initializeOpenGLFunctions()
@ -244,14 +240,6 @@ bool QOpenGLFunctions_2_0::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();

80
src/gui/opengl/qopenglfunctions_2_0.h
View File

@ -683,7 +683,7 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
};
// OpenGL 1.0 core functions
@ -931,12 +931,12 @@ inline void QOpenGLFunctions_2_0::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_2_0::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_2_0::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_2_0::glIsTexture(GLuint texture)
@ -996,7 +996,7 @@ inline void QOpenGLFunctions_2_0::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_2_0::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_2_0::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -3420,182 +3420,182 @@ inline void QOpenGLFunctions_2_0::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_2_0::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_2_0::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}

14
src/gui/opengl/qopenglfunctions_2_1.cpp
View File

@ -74,7 +74,7 @@ QOpenGLFunctions_2_1::QOpenGLFunctions_2_1()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
{
}
@ -132,10 +132,6 @@ QOpenGLFunctions_2_1::~QOpenGLFunctions_2_1()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
}
bool QOpenGLFunctions_2_1::initializeOpenGLFunctions()
@ -257,14 +253,6 @@ bool QOpenGLFunctions_2_1::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();

80
src/gui/opengl/qopenglfunctions_2_1.h
View File

@ -694,7 +694,7 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
};
// OpenGL 1.0 core functions
@ -942,12 +942,12 @@ inline void QOpenGLFunctions_2_1::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_2_1::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_2_1::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_2_1::glIsTexture(GLuint texture)
@ -1007,7 +1007,7 @@ inline void QOpenGLFunctions_2_1::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_2_1::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_2_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -3463,182 +3463,182 @@ inline void QOpenGLFunctions_2_1::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_2_1::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_2_1::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}

28
src/gui/opengl/qopenglfunctions_3_0.cpp
View File

@ -75,8 +75,8 @@ QOpenGLFunctions_3_0::QOpenGLFunctions_3_0()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, m_reserved_3_0_Deprecated(Q_NULLPTR)
{
}
@ -138,14 +138,6 @@ QOpenGLFunctions_3_0::~QOpenGLFunctions_3_0()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
}
}
bool QOpenGLFunctions_3_0::initializeOpenGLFunctions()
@ -275,22 +267,6 @@ bool QOpenGLFunctions_3_0::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();

122
src/gui/opengl/qopenglfunctions_3_0.h
View File

@ -783,8 +783,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
void *m_reserved_3_0_Deprecated; // To maintain BC
};
// OpenGL 1.0 core functions
@ -1032,12 +1032,12 @@ inline void QOpenGLFunctions_3_0::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_3_0::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_3_0::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_3_0::glIsTexture(GLuint texture)
@ -1097,7 +1097,7 @@ inline void QOpenGLFunctions_3_0::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_3_0::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_3_0::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -3875,182 +3875,182 @@ inline void QOpenGLFunctions_3_0::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_3_0::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -4059,102 +4059,102 @@ inline void QOpenGLFunctions_3_0::glVertexAttrib1d(GLuint index, GLdouble x)
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_3_0::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_3_0::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

10
src/gui/opengl/qopenglfunctions_3_1.h
View File

@ -587,12 +587,14 @@ inline void QOpenGLFunctions_3_1::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_3_1::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_1::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_3_1::glIsTexture(GLuint texture)
@ -652,7 +654,9 @@ inline void QOpenGLFunctions_3_1::glPolygonOffset(GLfloat factor, GLfloat units)
inline void QOpenGLFunctions_3_1::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

28
src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp
View File

@ -77,8 +77,8 @@ QOpenGLFunctions_3_2_Compatibility::QOpenGLFunctions_3_2_Compatibility()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, m_reserved_3_0_Deprecated(Q_NULLPTR)
{
}
@ -148,14 +148,6 @@ QOpenGLFunctions_3_2_Compatibility::~QOpenGLFunctions_3_2_Compatibility()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
}
}
bool QOpenGLFunctions_3_2_Compatibility::initializeOpenGLFunctions()
@ -301,22 +293,6 @@ bool QOpenGLFunctions_3_2_Compatibility::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();

122
src/gui/opengl/qopenglfunctions_3_2_compatibility.h
View File

@ -824,8 +824,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
void *m_reserved_3_0_Deprecated; // To maintain BC
};
// OpenGL 1.0 core functions
@ -1073,12 +1073,12 @@ inline void QOpenGLFunctions_3_2_Compatibility::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_3_2_Compatibility::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_3_2_Compatibility::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsTexture(GLuint texture)
@ -1138,7 +1138,7 @@ inline void QOpenGLFunctions_3_2_Compatibility::glPolygonOffset(GLfloat factor,
inline void QOpenGLFunctions_3_2_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_3_2_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -4075,182 +4075,182 @@ inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -4259,102 +4259,102 @@ inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1d(GLuint index, G
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

10
src/gui/opengl/qopenglfunctions_3_2_core.h
View File

@ -609,12 +609,14 @@ inline void QOpenGLFunctions_3_2_Core::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_3_2_Core::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_2_Core::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_3_2_Core::glIsTexture(GLuint texture)
@ -674,7 +676,9 @@ inline void QOpenGLFunctions_3_2_Core::glPolygonOffset(GLfloat factor, GLfloat u
inline void QOpenGLFunctions_3_2_Core::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_2_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)

30
src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp
View File

@ -78,8 +78,8 @@ QOpenGLFunctions_3_3_Compatibility::QOpenGLFunctions_3_3_Compatibility()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, d_3_3_Deprecated(0)
{
}
@ -153,13 +153,9 @@ QOpenGLFunctions_3_3_Compatibility::~QOpenGLFunctions_3_3_Compatibility()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
}
@ -314,20 +310,12 @@ bool QOpenGLFunctions_3_3_Compatibility::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();

182
src/gui/opengl/qopenglfunctions_3_3_compatibility.h
View File

@ -887,8 +887,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
};
// OpenGL 1.0 core functions
@ -1136,12 +1136,12 @@ inline void QOpenGLFunctions_3_3_Compatibility::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_3_3_Compatibility::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_3_3_Compatibility::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsTexture(GLuint texture)
@ -1201,7 +1201,7 @@ inline void QOpenGLFunctions_3_3_Compatibility::glPolygonOffset(GLfloat factor,
inline void QOpenGLFunctions_3_3_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_3_3_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -2271,152 +2271,152 @@ inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1ui(GLuint index,
inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
}
inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
d_3_3_Deprecated->SecondaryColorP3ui(type, color);
}
inline void QOpenGLFunctions_3_3_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
d_3_3_Deprecated->ColorP4uiv(type, color);
}
inline void QOpenGLFunctions_3_3_Compatibility::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
d_3_3_Deprecated->ColorP4ui(type, color);
}
inline void QOpenGLFunctions_3_3_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
d_3_3_Deprecated->ColorP3uiv(type, color);
}
inline void QOpenGLFunctions_3_3_Compatibility::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
d_3_3_Deprecated->ColorP3ui(type, color);
}
inline void QOpenGLFunctions_3_3_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
d_3_3_Deprecated->NormalP3uiv(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
d_3_3_Deprecated->NormalP3ui(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
d_3_3_Deprecated->TexCoordP4uiv(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
d_3_3_Deprecated->TexCoordP4ui(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
d_3_3_Deprecated->TexCoordP3uiv(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
d_3_3_Deprecated->TexCoordP3ui(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
d_3_3_Deprecated->TexCoordP2uiv(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
d_3_3_Deprecated->TexCoordP2ui(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
d_3_3_Deprecated->TexCoordP1uiv(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
d_3_3_Deprecated->TexCoordP1ui(type, coords);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
d_3_3_Deprecated->VertexP4uiv(type, value);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
d_3_3_Deprecated->VertexP4ui(type, value);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
d_3_3_Deprecated->VertexP3uiv(type, value);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
d_3_3_Deprecated->VertexP3ui(type, value);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
d_3_3_Deprecated->VertexP2uiv(type, value);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
d_3_3_Deprecated->VertexP2ui(type, value);
}
inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
@ -4430,182 +4430,182 @@ inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -4614,102 +4614,102 @@ inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1d(GLuint index, G
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

138
src/gui/opengl/qopenglfunctions_3_3_core.h
View File

@ -670,12 +670,14 @@ inline void QOpenGLFunctions_3_3_Core::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_3_3_Core::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_3_3_Core::glIsTexture(GLuint texture)
@ -735,7 +737,9 @@ inline void QOpenGLFunctions_3_3_Core::glPolygonOffset(GLfloat factor, GLfloat u
inline void QOpenGLFunctions_3_3_Core::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -1805,152 +1809,220 @@ inline void QOpenGLFunctions_3_3_Core::glVertexAttribP1ui(GLuint index, GLenum t
inline void QOpenGLFunctions_3_3_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)

30
src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp
View File

@ -79,8 +79,8 @@ QOpenGLFunctions_4_0_Compatibility::QOpenGLFunctions_4_0_Compatibility()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, d_3_3_Deprecated(0)
{
}
@ -158,13 +158,9 @@ QOpenGLFunctions_4_0_Compatibility::~QOpenGLFunctions_4_0_Compatibility()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
}
@ -327,20 +323,12 @@ bool QOpenGLFunctions_4_0_Compatibility::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();

182
src/gui/opengl/qopenglfunctions_4_0_compatibility.h
View File

@ -938,8 +938,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
};
// OpenGL 1.0 core functions
@ -1187,12 +1187,12 @@ inline void QOpenGLFunctions_4_0_Compatibility::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_0_Compatibility::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_4_0_Compatibility::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsTexture(GLuint texture)
@ -1252,7 +1252,7 @@ inline void QOpenGLFunctions_4_0_Compatibility::glPolygonOffset(GLfloat factor,
inline void QOpenGLFunctions_4_0_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_4_0_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -2322,152 +2322,152 @@ inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP1ui(GLuint index,
inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
d_3_3_Deprecated->SecondaryColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_0_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
d_3_3_Deprecated->ColorP4uiv(type, color);
}
inline void QOpenGLFunctions_4_0_Compatibility::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
d_3_3_Deprecated->ColorP4ui(type, color);
}
inline void QOpenGLFunctions_4_0_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
d_3_3_Deprecated->ColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_0_Compatibility::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
d_3_3_Deprecated->ColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_0_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
d_3_3_Deprecated->NormalP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
d_3_3_Deprecated->NormalP3ui(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
d_3_3_Deprecated->TexCoordP4uiv(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
d_3_3_Deprecated->TexCoordP4ui(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
d_3_3_Deprecated->TexCoordP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
d_3_3_Deprecated->TexCoordP3ui(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
d_3_3_Deprecated->TexCoordP2uiv(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
d_3_3_Deprecated->TexCoordP2ui(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
d_3_3_Deprecated->TexCoordP1uiv(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
d_3_3_Deprecated->TexCoordP1ui(type, coords);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
d_3_3_Deprecated->VertexP4uiv(type, value);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
d_3_3_Deprecated->VertexP4ui(type, value);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
d_3_3_Deprecated->VertexP3uiv(type, value);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
d_3_3_Deprecated->VertexP3ui(type, value);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
d_3_3_Deprecated->VertexP2uiv(type, value);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
d_3_3_Deprecated->VertexP2ui(type, value);
}
inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
@ -4713,182 +4713,182 @@ inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -4897,102 +4897,102 @@ inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1d(GLuint index, G
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

138
src/gui/opengl/qopenglfunctions_4_0_core.h
View File

@ -719,12 +719,14 @@ inline void QOpenGLFunctions_4_0_Core::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_0_Core::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_4_0_Core::glIsTexture(GLuint texture)
@ -784,7 +786,9 @@ inline void QOpenGLFunctions_4_0_Core::glPolygonOffset(GLfloat factor, GLfloat u
inline void QOpenGLFunctions_4_0_Core::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -1854,152 +1858,220 @@ inline void QOpenGLFunctions_4_0_Core::glVertexAttribP1ui(GLuint index, GLenum t
inline void QOpenGLFunctions_4_0_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)

30
src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp
View File

@ -80,8 +80,8 @@ QOpenGLFunctions_4_1_Compatibility::QOpenGLFunctions_4_1_Compatibility()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, d_3_3_Deprecated(0)
{
}
@ -163,13 +163,9 @@ QOpenGLFunctions_4_1_Compatibility::~QOpenGLFunctions_4_1_Compatibility()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
}
@ -340,20 +336,12 @@ bool QOpenGLFunctions_4_1_Compatibility::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();

182
src/gui/opengl/qopenglfunctions_4_1_compatibility.h
View File

@ -1031,8 +1031,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
};
// OpenGL 1.0 core functions
@ -1280,12 +1280,12 @@ inline void QOpenGLFunctions_4_1_Compatibility::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_1_Compatibility::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_4_1_Compatibility::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsTexture(GLuint texture)
@ -1345,7 +1345,7 @@ inline void QOpenGLFunctions_4_1_Compatibility::glPolygonOffset(GLfloat factor,
inline void QOpenGLFunctions_4_1_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_4_1_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -2415,152 +2415,152 @@ inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP1ui(GLuint index,
inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
d_3_3_Deprecated->SecondaryColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_1_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
d_3_3_Deprecated->ColorP4uiv(type, color);
}
inline void QOpenGLFunctions_4_1_Compatibility::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
d_3_3_Deprecated->ColorP4ui(type, color);
}
inline void QOpenGLFunctions_4_1_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
d_3_3_Deprecated->ColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_1_Compatibility::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
d_3_3_Deprecated->ColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_1_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
d_3_3_Deprecated->NormalP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
d_3_3_Deprecated->NormalP3ui(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
d_3_3_Deprecated->TexCoordP4uiv(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
d_3_3_Deprecated->TexCoordP4ui(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
d_3_3_Deprecated->TexCoordP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
d_3_3_Deprecated->TexCoordP3ui(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
d_3_3_Deprecated->TexCoordP2uiv(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
d_3_3_Deprecated->TexCoordP2ui(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
d_3_3_Deprecated->TexCoordP1uiv(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
d_3_3_Deprecated->TexCoordP1ui(type, coords);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
d_3_3_Deprecated->VertexP4uiv(type, value);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
d_3_3_Deprecated->VertexP4ui(type, value);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
d_3_3_Deprecated->VertexP3uiv(type, value);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
d_3_3_Deprecated->VertexP3ui(type, value);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
d_3_3_Deprecated->VertexP2uiv(type, value);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
d_3_3_Deprecated->VertexP2ui(type, value);
}
inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
@ -5248,182 +5248,182 @@ inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -5432,102 +5432,102 @@ inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1d(GLuint index, G
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

138
src/gui/opengl/qopenglfunctions_4_1_core.h
View File

@ -810,12 +810,14 @@ inline void QOpenGLFunctions_4_1_Core::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_1_Core::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_4_1_Core::glIsTexture(GLuint texture)
@ -875,7 +877,9 @@ inline void QOpenGLFunctions_4_1_Core::glPolygonOffset(GLfloat factor, GLfloat u
inline void QOpenGLFunctions_4_1_Core::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -1945,152 +1949,220 @@ inline void QOpenGLFunctions_4_1_Core::glVertexAttribP1ui(GLuint index, GLenum t
inline void QOpenGLFunctions_4_1_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)

30
src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp
View File

@ -81,8 +81,8 @@ QOpenGLFunctions_4_2_Compatibility::QOpenGLFunctions_4_2_Compatibility()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, d_3_3_Deprecated(0)
{
}
@ -168,13 +168,9 @@ QOpenGLFunctions_4_2_Compatibility::~QOpenGLFunctions_4_2_Compatibility()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
}
@ -353,20 +349,12 @@ bool QOpenGLFunctions_4_2_Compatibility::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();

182
src/gui/opengl/qopenglfunctions_4_2_compatibility.h
View File

@ -1048,8 +1048,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
};
// OpenGL 1.0 core functions
@ -1297,12 +1297,12 @@ inline void QOpenGLFunctions_4_2_Compatibility::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_2_Compatibility::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_4_2_Compatibility::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsTexture(GLuint texture)
@ -1362,7 +1362,7 @@ inline void QOpenGLFunctions_4_2_Compatibility::glPolygonOffset(GLfloat factor,
inline void QOpenGLFunctions_4_2_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_4_2_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -2432,152 +2432,152 @@ inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP1ui(GLuint index,
inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
d_3_3_Deprecated->SecondaryColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_2_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
d_3_3_Deprecated->ColorP4uiv(type, color);
}
inline void QOpenGLFunctions_4_2_Compatibility::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
d_3_3_Deprecated->ColorP4ui(type, color);
}
inline void QOpenGLFunctions_4_2_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
d_3_3_Deprecated->ColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_2_Compatibility::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
d_3_3_Deprecated->ColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_2_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
d_3_3_Deprecated->NormalP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
d_3_3_Deprecated->NormalP3ui(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
d_3_3_Deprecated->TexCoordP4uiv(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
d_3_3_Deprecated->TexCoordP4ui(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
d_3_3_Deprecated->TexCoordP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
d_3_3_Deprecated->TexCoordP3ui(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
d_3_3_Deprecated->TexCoordP2uiv(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
d_3_3_Deprecated->TexCoordP2ui(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
d_3_3_Deprecated->TexCoordP1uiv(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
d_3_3_Deprecated->TexCoordP1ui(type, coords);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
d_3_3_Deprecated->VertexP4uiv(type, value);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
d_3_3_Deprecated->VertexP4ui(type, value);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
d_3_3_Deprecated->VertexP3uiv(type, value);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
d_3_3_Deprecated->VertexP3ui(type, value);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
d_3_3_Deprecated->VertexP2uiv(type, value);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
d_3_3_Deprecated->VertexP2ui(type, value);
}
inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
@ -5327,182 +5327,182 @@ inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -5511,102 +5511,102 @@ inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1d(GLuint index, G
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

138
src/gui/opengl/qopenglfunctions_4_2_core.h
View File

@ -825,12 +825,14 @@ inline void QOpenGLFunctions_4_2_Core::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_2_Core::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_4_2_Core::glIsTexture(GLuint texture)
@ -890,7 +892,9 @@ inline void QOpenGLFunctions_4_2_Core::glPolygonOffset(GLfloat factor, GLfloat u
inline void QOpenGLFunctions_4_2_Core::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -1960,152 +1964,220 @@ inline void QOpenGLFunctions_4_2_Core::glVertexAttribP1ui(GLuint index, GLenum t
inline void QOpenGLFunctions_4_2_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)

30
src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp
View File

@ -82,8 +82,8 @@ QOpenGLFunctions_4_3_Compatibility::QOpenGLFunctions_4_3_Compatibility()
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_2_0_Deprecated(0)
, d_3_0_Deprecated(0)
, m_reserved_2_0_Deprecated(Q_NULLPTR)
, d_3_3_Deprecated(0)
{
}
@ -173,13 +173,9 @@ QOpenGLFunctions_4_3_Compatibility::~QOpenGLFunctions_4_3_Compatibility()
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_2_0_Deprecated && !d_2_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Deprecated->context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
delete d_2_0_Deprecated;
}
if (d_3_0_Deprecated && !d_3_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Deprecated->context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
delete d_3_0_Deprecated;
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
}
@ -366,20 +362,12 @@ bool QOpenGLFunctions_4_3_Compatibility::initializeOpenGLFunctions()
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus());
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus(), d);
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_2_0_Deprecated = static_cast<QOpenGLFunctions_2_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus(), d);
}
d_3_0_Deprecated = static_cast<QOpenGLFunctions_3_0_DeprecatedBackend*>(d);
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();

182
src/gui/opengl/qopenglfunctions_4_3_compatibility.h
View File

@ -1086,8 +1086,8 @@ private:
QOpenGLFunctions_1_2_DeprecatedBackend* d_1_2_Deprecated;
QOpenGLFunctions_1_3_DeprecatedBackend* d_1_3_Deprecated;
QOpenGLFunctions_1_4_DeprecatedBackend* d_1_4_Deprecated;
QOpenGLFunctions_2_0_DeprecatedBackend* d_2_0_Deprecated;
QOpenGLFunctions_3_0_DeprecatedBackend* d_3_0_Deprecated;
void *m_reserved_2_0_Deprecated; // To maintain BC
QOpenGLFunctions_3_3_DeprecatedBackend* d_3_3_Deprecated;
};
// OpenGL 1.0 core functions
@ -1335,12 +1335,12 @@ inline void QOpenGLFunctions_4_3_Compatibility::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_3_Compatibility::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
d_1_1_Deprecated->Indexubv(c);
}
inline void QOpenGLFunctions_4_3_Compatibility::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
d_1_1_Deprecated->Indexub(c);
}
inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsTexture(GLuint texture)
@ -1400,7 +1400,7 @@ inline void QOpenGLFunctions_4_3_Compatibility::glPolygonOffset(GLfloat factor,
inline void QOpenGLFunctions_4_3_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
d_1_1_Deprecated->GetPointerv(pname, params);
}
inline void QOpenGLFunctions_4_3_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -2470,152 +2470,152 @@ inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP1ui(GLuint index,
inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
d_3_3_Deprecated->SecondaryColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_3_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
d_3_3_Deprecated->ColorP4uiv(type, color);
}
inline void QOpenGLFunctions_4_3_Compatibility::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
d_3_3_Deprecated->ColorP4ui(type, color);
}
inline void QOpenGLFunctions_4_3_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
d_3_3_Deprecated->ColorP3uiv(type, color);
}
inline void QOpenGLFunctions_4_3_Compatibility::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
d_3_3_Deprecated->ColorP3ui(type, color);
}
inline void QOpenGLFunctions_4_3_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
d_3_3_Deprecated->NormalP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
d_3_3_Deprecated->NormalP3ui(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
d_3_3_Deprecated->TexCoordP4uiv(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
d_3_3_Deprecated->TexCoordP4ui(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
d_3_3_Deprecated->TexCoordP3uiv(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
d_3_3_Deprecated->TexCoordP3ui(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
d_3_3_Deprecated->TexCoordP2uiv(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
d_3_3_Deprecated->TexCoordP2ui(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
d_3_3_Deprecated->TexCoordP1uiv(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
d_3_3_Deprecated->TexCoordP1ui(type, coords);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
d_3_3_Deprecated->VertexP4uiv(type, value);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
d_3_3_Deprecated->VertexP4ui(type, value);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
d_3_3_Deprecated->VertexP3uiv(type, value);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
d_3_3_Deprecated->VertexP3ui(type, value);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
d_3_3_Deprecated->VertexP2uiv(type, value);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
d_3_3_Deprecated->VertexP2ui(type, value);
}
inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
@ -5532,182 +5532,182 @@ inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordf(GLfloat coord)
// OpenGL 2.0 deprecated functions
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4usv(index, v);
d_2_0_Core->VertexAttrib4usv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4uiv(index, v);
d_2_0_Core->VertexAttrib4uiv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4ubv(index, v);
d_2_0_Core->VertexAttrib4ubv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4sv(index, v);
d_2_0_Core->VertexAttrib4sv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
d_2_0_Deprecated->VertexAttrib4s(index, x, y, z, w);
d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4iv(index, v);
d_2_0_Core->VertexAttrib4iv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib4fv(index, v);
d_2_0_Core->VertexAttrib4fv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
d_2_0_Deprecated->VertexAttrib4f(index, x, y, z, w);
d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib4dv(index, v);
d_2_0_Core->VertexAttrib4dv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
d_2_0_Deprecated->VertexAttrib4d(index, x, y, z, w);
d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4bv(index, v);
d_2_0_Core->VertexAttrib4bv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
d_2_0_Deprecated->VertexAttrib4Nusv(index, v);
d_2_0_Core->VertexAttrib4Nusv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
d_2_0_Deprecated->VertexAttrib4Nuiv(index, v);
d_2_0_Core->VertexAttrib4Nuiv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nubv(index, v);
d_2_0_Core->VertexAttrib4Nubv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
d_2_0_Deprecated->VertexAttrib4Nub(index, x, y, z, w);
d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib4Nsv(index, v);
d_2_0_Core->VertexAttrib4Nsv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
{
d_2_0_Deprecated->VertexAttrib4Niv(index, v);
d_2_0_Core->VertexAttrib4Niv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
d_2_0_Deprecated->VertexAttrib4Nbv(index, v);
d_2_0_Core->VertexAttrib4Nbv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib3sv(index, v);
d_2_0_Core->VertexAttrib3sv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
d_2_0_Deprecated->VertexAttrib3s(index, x, y, z);
d_2_0_Core->VertexAttrib3s(index, x, y, z);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib3fv(index, v);
d_2_0_Core->VertexAttrib3fv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
d_2_0_Deprecated->VertexAttrib3f(index, x, y, z);
d_2_0_Core->VertexAttrib3f(index, x, y, z);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib3dv(index, v);
d_2_0_Core->VertexAttrib3dv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
d_2_0_Deprecated->VertexAttrib3d(index, x, y, z);
d_2_0_Core->VertexAttrib3d(index, x, y, z);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib2sv(index, v);
d_2_0_Core->VertexAttrib2sv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
d_2_0_Deprecated->VertexAttrib2s(index, x, y);
d_2_0_Core->VertexAttrib2s(index, x, y);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib2fv(index, v);
d_2_0_Core->VertexAttrib2fv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
d_2_0_Deprecated->VertexAttrib2f(index, x, y);
d_2_0_Core->VertexAttrib2f(index, x, y);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib2dv(index, v);
d_2_0_Core->VertexAttrib2dv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
d_2_0_Deprecated->VertexAttrib2d(index, x, y);
d_2_0_Core->VertexAttrib2d(index, x, y);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
{
d_2_0_Deprecated->VertexAttrib1sv(index, v);
d_2_0_Core->VertexAttrib1sv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
{
d_2_0_Deprecated->VertexAttrib1s(index, x);
d_2_0_Core->VertexAttrib1s(index, x);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
{
d_2_0_Deprecated->VertexAttrib1fv(index, v);
d_2_0_Core->VertexAttrib1fv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
{
d_2_0_Deprecated->VertexAttrib1f(index, x);
d_2_0_Core->VertexAttrib1f(index, x);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
{
d_2_0_Deprecated->VertexAttrib1dv(index, v);
d_2_0_Core->VertexAttrib1dv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
{
d_2_0_Deprecated->VertexAttrib1d(index, x);
d_2_0_Core->VertexAttrib1d(index, x);
}
@ -5716,102 +5716,102 @@ inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1d(GLuint index, G
// OpenGL 3.0 deprecated functions
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
{
d_3_0_Deprecated->VertexAttribI4usv(index, v);
d_3_0_Core->VertexAttribI4usv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
d_3_0_Deprecated->VertexAttribI4ubv(index, v);
d_3_0_Core->VertexAttribI4ubv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
{
d_3_0_Deprecated->VertexAttribI4sv(index, v);
d_3_0_Core->VertexAttribI4sv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
{
d_3_0_Deprecated->VertexAttribI4bv(index, v);
d_3_0_Core->VertexAttribI4bv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI4uiv(index, v);
d_3_0_Core->VertexAttribI4uiv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI3uiv(index, v);
d_3_0_Core->VertexAttribI3uiv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI2uiv(index, v);
d_3_0_Core->VertexAttribI2uiv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
{
d_3_0_Deprecated->VertexAttribI1uiv(index, v);
d_3_0_Core->VertexAttribI1uiv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI4iv(index, v);
d_3_0_Core->VertexAttribI4iv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI3iv(index, v);
d_3_0_Core->VertexAttribI3iv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI2iv(index, v);
d_3_0_Core->VertexAttribI2iv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
{
d_3_0_Deprecated->VertexAttribI1iv(index, v);
d_3_0_Core->VertexAttribI1iv(index, v);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
d_3_0_Deprecated->VertexAttribI4ui(index, x, y, z, w);
d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
d_3_0_Deprecated->VertexAttribI3ui(index, x, y, z);
d_3_0_Core->VertexAttribI3ui(index, x, y, z);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
d_3_0_Deprecated->VertexAttribI2ui(index, x, y);
d_3_0_Core->VertexAttribI2ui(index, x, y);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
{
d_3_0_Deprecated->VertexAttribI1ui(index, x);
d_3_0_Core->VertexAttribI1ui(index, x);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
d_3_0_Deprecated->VertexAttribI4i(index, x, y, z, w);
d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
d_3_0_Deprecated->VertexAttribI3i(index, x, y, z);
d_3_0_Core->VertexAttribI3i(index, x, y, z);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
d_3_0_Deprecated->VertexAttribI2i(index, x, y);
d_3_0_Core->VertexAttribI2i(index, x, y);
}
inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
{
d_3_0_Deprecated->VertexAttribI1i(index, x);
d_3_0_Core->VertexAttribI1i(index, x);
}

138
src/gui/opengl/qopenglfunctions_4_3_core.h
View File

@ -861,12 +861,14 @@ inline void QOpenGLFunctions_4_3_Core::glCullFace(GLenum mode)
// OpenGL 1.1 core functions
inline void QOpenGLFunctions_4_3_Core::glIndexubv(const GLubyte *c)
{
d_1_1_Core->Indexubv(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glIndexub(GLubyte c)
{
d_1_1_Core->Indexub(c);
Q_UNUSED(c);
QOPENGL_DEPRECATEDFUNCTION;
}
inline GLboolean QOpenGLFunctions_4_3_Core::glIsTexture(GLuint texture)
@ -926,7 +928,9 @@ inline void QOpenGLFunctions_4_3_Core::glPolygonOffset(GLfloat factor, GLfloat u
inline void QOpenGLFunctions_4_3_Core::glGetPointerv(GLenum pname, GLvoid* *params)
{
d_1_1_Core->GetPointerv(pname, params);
Q_UNUSED(pname);
Q_UNUSED(params);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
@ -1996,152 +2000,220 @@ inline void QOpenGLFunctions_4_3_Core::glVertexAttribP1ui(GLuint index, GLenum t
inline void QOpenGLFunctions_4_3_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->SecondaryColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glSecondaryColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->SecondaryColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glColorP4uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP4uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glColorP4ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP4ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glColorP3uiv(GLenum type, const GLuint *color)
{
d_3_3_Core->ColorP3uiv(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glColorP3ui(GLenum type, GLuint color)
{
d_3_3_Core->ColorP3ui(type, color);
Q_UNUSED(type);
Q_UNUSED(color);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glNormalP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->NormalP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glNormalP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->NormalP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP4uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP4ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP3uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP3ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP2uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP2ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
d_3_3_Core->MultiTexCoordP1uiv(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
d_3_3_Core->MultiTexCoordP1ui(texture, type, coords);
Q_UNUSED(texture);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP4uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP4uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP4ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP4ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP3uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP3uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP3ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP3ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP2uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP2uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP2ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP2ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP1uiv(GLenum type, const GLuint *coords)
{
d_3_3_Core->TexCoordP1uiv(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glTexCoordP1ui(GLenum type, GLuint coords)
{
d_3_3_Core->TexCoordP1ui(type, coords);
Q_UNUSED(type);
Q_UNUSED(coords);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glVertexP4uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP4uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glVertexP4ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP4ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glVertexP3uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP3uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glVertexP3ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP3ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glVertexP2uiv(GLenum type, const GLuint *value)
{
d_3_3_Core->VertexP2uiv(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glVertexP2ui(GLenum type, GLuint value)
{
d_3_3_Core->VertexP2ui(type, value);
Q_UNUSED(type);
Q_UNUSED(value);
QOPENGL_DEPRECATEDFUNCTION;
}
inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)

412
src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp Normal file
View File

@ -0,0 +1,412 @@
/****************************************************************************
**
** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
**
** This file was generated by glgen version 0.1
** Command line was: glgen
**
** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
**
** This is an auto-generated file.
** Do not edit! All changes made to it will be lost.
**
****************************************************************************/
#include "qopenglfunctions_4_4_compatibility.h"
#include "qopenglcontext.h"
QT_BEGIN_NAMESPACE
/*!
\class QOpenGLFunctions_4_4_Compatibility
\inmodule QtGui
\since 5.5
\wrapper
\brief The QOpenGLFunctions_4_4_Compatibility class provides all functions for OpenGL 4.4 compatibility profile.
This class is a wrapper for functions from OpenGL 4.4 compatibility profile.
See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
for function documentation.
\sa QAbstractOpenGLFunctions
*/
QOpenGLFunctions_4_4_Compatibility::QOpenGLFunctions_4_4_Compatibility()
: QAbstractOpenGLFunctions()
, d_1_0_Core(0)
, d_1_1_Core(0)
, d_1_2_Core(0)
, d_1_3_Core(0)
, d_1_4_Core(0)
, d_1_5_Core(0)
, d_2_0_Core(0)
, d_2_1_Core(0)
, d_3_0_Core(0)
, d_3_1_Core(0)
, d_3_2_Core(0)
, d_3_3_Core(0)
, d_4_0_Core(0)
, d_4_1_Core(0)
, d_4_2_Core(0)
, d_4_3_Core(0)
, d_4_4_Core(0)
, d_1_0_Deprecated(0)
, d_1_1_Deprecated(0)
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_3_3_Deprecated(0)
{
}
QOpenGLFunctions_4_4_Compatibility::~QOpenGLFunctions_4_4_Compatibility()
{
if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
delete d_1_0_Core;
}
if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
delete d_1_1_Core;
}
if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
delete d_1_2_Core;
}
if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
delete d_1_3_Core;
}
if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
delete d_1_4_Core;
}
if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
delete d_1_5_Core;
}
if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
delete d_2_0_Core;
}
if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
delete d_2_1_Core;
}
if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
delete d_3_0_Core;
}
if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
delete d_3_1_Core;
}
if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
delete d_3_2_Core;
}
if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
delete d_3_3_Core;
}
if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
delete d_4_0_Core;
}
if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
delete d_4_1_Core;
}
if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
delete d_4_2_Core;
}
if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
delete d_4_3_Core;
}
if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
delete d_4_4_Core;
}
if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
delete d_1_0_Deprecated;
}
if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
delete d_1_1_Deprecated;
}
if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
delete d_1_2_Deprecated;
}
if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
delete d_1_3_Deprecated;
}
if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
}
bool QOpenGLFunctions_4_4_Compatibility::initializeOpenGLFunctions()
{
if ( isInitialized() )
return true;
QOpenGLContext* context = QOpenGLContext::currentContext();
// If owned by a context object make sure it is current.
// Also check that current context is capable of resolving all needed functions
if (((owningContext() && owningContext() == context) || !owningContext())
&& QOpenGLFunctions_4_4_Compatibility::isContextCompatible(context))
{
// Associate with private implementation, creating if necessary
// Function pointers in the backends are resolved at creation time
QOpenGLVersionFunctionsBackend* d = 0;
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
}
d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
}
d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
}
d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
}
d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
}
d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_5_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
}
d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
}
d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
}
d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
}
d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
}
d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
}
d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
}
d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
}
d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
}
d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
}
d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
}
d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
}
d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
}
d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
}
d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
}
d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
}
d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
}
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();
}
bool QOpenGLFunctions_4_4_Compatibility::isContextCompatible(QOpenGLContext *context)
{
Q_ASSERT(context);
QSurfaceFormat f = context->format();
const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
if (v < qMakePair(4, 4))
return false;
if (f.profile() == QSurfaceFormat::CoreProfile)
return false;
return true;
}
QOpenGLVersionProfile QOpenGLFunctions_4_4_Compatibility::versionProfile()
{
QOpenGLVersionProfile v;
v.setVersion(4, 4);
v.setProfile(QSurfaceFormat::CompatibilityProfile);
return v;
}
QT_END_NAMESPACE

5959
src/gui/opengl/qopenglfunctions_4_4_compatibility.h Normal file
View File

File diff suppressed because it is too large Load Diff

331
src/gui/opengl/qopenglfunctions_4_4_core.cpp Normal file
View File

@ -0,0 +1,331 @@
/****************************************************************************
**
** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
**
** This file was generated by glgen version 0.1
** Command line was: glgen
**
** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
**
** This is an auto-generated file.
** Do not edit! All changes made to it will be lost.
**
****************************************************************************/
#include "qopenglfunctions_4_4_core.h"
#include "qopenglcontext.h"
QT_BEGIN_NAMESPACE
/*!
\class QOpenGLFunctions_4_4_Core
\inmodule QtGui
\since 5.5
\wrapper
\brief The QOpenGLFunctions_4_4_Core class provides all functions for OpenGL 4.4 core profile.
This class is a wrapper for functions from OpenGL 4.4 core profile.
See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
for function documentation.
\sa QAbstractOpenGLFunctions
*/
QOpenGLFunctions_4_4_Core::QOpenGLFunctions_4_4_Core()
: QAbstractOpenGLFunctions()
, d_1_0_Core(0)
, d_1_1_Core(0)
, d_1_2_Core(0)
, d_1_3_Core(0)
, d_1_4_Core(0)
, d_1_5_Core(0)
, d_2_0_Core(0)
, d_2_1_Core(0)
, d_3_0_Core(0)
, d_3_1_Core(0)
, d_3_2_Core(0)
, d_3_3_Core(0)
, d_4_0_Core(0)
, d_4_1_Core(0)
, d_4_2_Core(0)
, d_4_3_Core(0)
, d_4_4_Core(0)
{
}
QOpenGLFunctions_4_4_Core::~QOpenGLFunctions_4_4_Core()
{
if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
delete d_1_0_Core;
}
if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
delete d_1_1_Core;
}
if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
delete d_1_2_Core;
}
if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
delete d_1_3_Core;
}
if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
delete d_1_4_Core;
}
if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
delete d_1_5_Core;
}
if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
delete d_2_0_Core;
}
if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
delete d_2_1_Core;
}
if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
delete d_3_0_Core;
}
if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
delete d_3_1_Core;
}
if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
delete d_3_2_Core;
}
if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
delete d_3_3_Core;
}
if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
delete d_4_0_Core;
}
if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
delete d_4_1_Core;
}
if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
delete d_4_2_Core;
}
if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
delete d_4_3_Core;
}
if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
delete d_4_4_Core;
}
}
bool QOpenGLFunctions_4_4_Core::initializeOpenGLFunctions()
{
if ( isInitialized() )
return true;
QOpenGLContext* context = QOpenGLContext::currentContext();
// If owned by a context object make sure it is current.
// Also check that current context is capable of resolving all needed functions
if (((owningContext() && owningContext() == context) || !owningContext())
&& QOpenGLFunctions_4_4_Core::isContextCompatible(context))
{
// Associate with private implementation, creating if necessary
// Function pointers in the backends are resolved at creation time
QOpenGLVersionFunctionsBackend* d = 0;
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
}
d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
}
d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
}
d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
}
d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
}
d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_5_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
}
d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
}
d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
}
d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
}
d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
}
d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
}
d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
}
d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
}
d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
}
d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
}
d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
}
d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
}
d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();
}
bool QOpenGLFunctions_4_4_Core::isContextCompatible(QOpenGLContext *context)
{
Q_ASSERT(context);
QSurfaceFormat f = context->format();
const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
if (v < qMakePair(4, 4))
return false;
return true;
}
QOpenGLVersionProfile QOpenGLFunctions_4_4_Core::versionProfile()
{
QOpenGLVersionProfile v;
v.setVersion(4, 4);
v.setProfile(QSurfaceFormat::CoreProfile);
return v;
}
QT_END_NAMESPACE

3413
src/gui/opengl/qopenglfunctions_4_4_core.h Normal file
View File

File diff suppressed because it is too large Load Diff

438
src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp Normal file
View File

@ -0,0 +1,438 @@
/****************************************************************************
**
** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
**
** This file was generated by glgen version 0.1
** Command line was: glgen
**
** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
**
** This is an auto-generated file.
** Do not edit! All changes made to it will be lost.
**
****************************************************************************/
#include "qopenglfunctions_4_5_compatibility.h"
#include "qopenglcontext.h"
QT_BEGIN_NAMESPACE
/*!
\class QOpenGLFunctions_4_5_Compatibility
\inmodule QtGui
\since 5.5
\wrapper
\brief The QOpenGLFunctions_4_5_Compatibility class provides all functions for OpenGL 4.5 compatibility profile.
This class is a wrapper for functions from OpenGL 4.5 compatibility profile.
See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
for function documentation.
\sa QAbstractOpenGLFunctions
*/
QOpenGLFunctions_4_5_Compatibility::QOpenGLFunctions_4_5_Compatibility()
: QAbstractOpenGLFunctions()
, d_1_0_Core(0)
, d_1_1_Core(0)
, d_1_2_Core(0)
, d_1_3_Core(0)
, d_1_4_Core(0)
, d_1_5_Core(0)
, d_2_0_Core(0)
, d_2_1_Core(0)
, d_3_0_Core(0)
, d_3_1_Core(0)
, d_3_2_Core(0)
, d_3_3_Core(0)
, d_4_0_Core(0)
, d_4_1_Core(0)
, d_4_2_Core(0)
, d_4_3_Core(0)
, d_4_4_Core(0)
, d_4_5_Core(0)
, d_1_0_Deprecated(0)
, d_1_1_Deprecated(0)
, d_1_2_Deprecated(0)
, d_1_3_Deprecated(0)
, d_1_4_Deprecated(0)
, d_3_3_Deprecated(0)
, d_4_5_Deprecated(0)
{
}
QOpenGLFunctions_4_5_Compatibility::~QOpenGLFunctions_4_5_Compatibility()
{
if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
delete d_1_0_Core;
}
if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
delete d_1_1_Core;
}
if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
delete d_1_2_Core;
}
if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
delete d_1_3_Core;
}
if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
delete d_1_4_Core;
}
if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
delete d_1_5_Core;
}
if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
delete d_2_0_Core;
}
if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
delete d_2_1_Core;
}
if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
delete d_3_0_Core;
}
if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
delete d_3_1_Core;
}
if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
delete d_3_2_Core;
}
if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
delete d_3_3_Core;
}
if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
delete d_4_0_Core;
}
if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
delete d_4_1_Core;
}
if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
delete d_4_2_Core;
}
if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
delete d_4_3_Core;
}
if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
delete d_4_4_Core;
}
if (d_4_5_Core && !d_4_5_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_5_Core->context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
delete d_4_5_Core;
}
if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
delete d_1_0_Deprecated;
}
if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
delete d_1_1_Deprecated;
}
if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
delete d_1_2_Deprecated;
}
if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
delete d_1_3_Deprecated;
}
if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
delete d_1_4_Deprecated;
}
if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
delete d_3_3_Deprecated;
}
if (d_4_5_Deprecated && !d_4_5_Deprecated->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_5_Deprecated->context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus());
delete d_4_5_Deprecated;
}
}
bool QOpenGLFunctions_4_5_Compatibility::initializeOpenGLFunctions()
{
if ( isInitialized() )
return true;
QOpenGLContext* context = QOpenGLContext::currentContext();
// If owned by a context object make sure it is current.
// Also check that current context is capable of resolving all needed functions
if (((owningContext() && owningContext() == context) || !owningContext())
&& QOpenGLFunctions_4_5_Compatibility::isContextCompatible(context))
{
// Associate with private implementation, creating if necessary
// Function pointers in the backends are resolved at creation time
QOpenGLVersionFunctionsBackend* d = 0;
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
}
d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
}
d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
}
d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
}
d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
}
d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_5_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
}
d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
}
d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
}
d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
}
d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
}
d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
}
d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
}
d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
}
d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
}
d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
}
d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
}
d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
}
d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_5_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus(), d);
}
d_4_5_Core = static_cast<QOpenGLFunctions_4_5_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
}
d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
}
d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
}
d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
}
d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
}
d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
}
d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_5_DeprecatedBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus(), d);
}
d_4_5_Deprecated = static_cast<QOpenGLFunctions_4_5_DeprecatedBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();
}
bool QOpenGLFunctions_4_5_Compatibility::isContextCompatible(QOpenGLContext *context)
{
Q_ASSERT(context);
QSurfaceFormat f = context->format();
const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
if (v < qMakePair(4, 5))
return false;
if (f.profile() == QSurfaceFormat::CoreProfile)
return false;
return true;
}
QOpenGLVersionProfile QOpenGLFunctions_4_5_Compatibility::versionProfile()
{
QOpenGLVersionProfile v;
v.setVersion(4, 5);
v.setProfile(QSurfaceFormat::CompatibilityProfile);
return v;
}
QT_END_NAMESPACE

6677
src/gui/opengl/qopenglfunctions_4_5_compatibility.h Normal file
View File

File diff suppressed because it is too large Load Diff

344
src/gui/opengl/qopenglfunctions_4_5_core.cpp Normal file
View File

@ -0,0 +1,344 @@
/****************************************************************************
**
** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
**
** This file was generated by glgen version 0.1
** Command line was: glgen
**
** glgen is Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
**
** This is an auto-generated file.
** Do not edit! All changes made to it will be lost.
**
****************************************************************************/
#include "qopenglfunctions_4_5_core.h"
#include "qopenglcontext.h"
QT_BEGIN_NAMESPACE
/*!
\class QOpenGLFunctions_4_5_Core
\inmodule QtGui
\since 5.5
\wrapper
\brief The QOpenGLFunctions_4_5_Core class provides all functions for OpenGL 4.5 core profile.
This class is a wrapper for functions from OpenGL 4.5 core profile.
See reference pages on \l {http://www.opengl.org/sdk/docs/}{opengl.org}
for function documentation.
\sa QAbstractOpenGLFunctions
*/
QOpenGLFunctions_4_5_Core::QOpenGLFunctions_4_5_Core()
: QAbstractOpenGLFunctions()
, d_1_0_Core(0)
, d_1_1_Core(0)
, d_1_2_Core(0)
, d_1_3_Core(0)
, d_1_4_Core(0)
, d_1_5_Core(0)
, d_2_0_Core(0)
, d_2_1_Core(0)
, d_3_0_Core(0)
, d_3_1_Core(0)
, d_3_2_Core(0)
, d_3_3_Core(0)
, d_4_0_Core(0)
, d_4_1_Core(0)
, d_4_2_Core(0)
, d_4_3_Core(0)
, d_4_4_Core(0)
, d_4_5_Core(0)
{
}
QOpenGLFunctions_4_5_Core::~QOpenGLFunctions_4_5_Core()
{
if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
delete d_1_0_Core;
}
if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
delete d_1_1_Core;
}
if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
delete d_1_2_Core;
}
if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
delete d_1_3_Core;
}
if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
delete d_1_4_Core;
}
if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
delete d_1_5_Core;
}
if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
delete d_2_0_Core;
}
if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
delete d_2_1_Core;
}
if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
delete d_3_0_Core;
}
if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
delete d_3_1_Core;
}
if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
delete d_3_2_Core;
}
if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
delete d_3_3_Core;
}
if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
delete d_4_0_Core;
}
if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
delete d_4_1_Core;
}
if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
delete d_4_2_Core;
}
if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
delete d_4_3_Core;
}
if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
delete d_4_4_Core;
}
if (d_4_5_Core && !d_4_5_Core->refs.deref()) {
QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_5_Core->context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
delete d_4_5_Core;
}
}
bool QOpenGLFunctions_4_5_Core::initializeOpenGLFunctions()
{
if ( isInitialized() )
return true;
QOpenGLContext* context = QOpenGLContext::currentContext();
// If owned by a context object make sure it is current.
// Also check that current context is capable of resolving all needed functions
if (((owningContext() && owningContext() == context) || !owningContext())
&& QOpenGLFunctions_4_5_Core::isContextCompatible(context))
{
// Associate with private implementation, creating if necessary
// Function pointers in the backends are resolved at creation time
QOpenGLVersionFunctionsBackend* d = 0;
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
}
d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
}
d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
}
d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
}
d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
}
d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_1_5_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
}
d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
}
d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_2_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
}
d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
}
d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
}
d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
}
d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_3_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
}
d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_0_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
}
d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_1_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
}
d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_2_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
}
d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_3_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
}
d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_4_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
}
d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
d->refs.ref();
d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
if (!d) {
d = new QOpenGLFunctions_4_5_CoreBackend(context);
QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus(), d);
}
d_4_5_Core = static_cast<QOpenGLFunctions_4_5_CoreBackend*>(d);
d->refs.ref();
QAbstractOpenGLFunctions::initializeOpenGLFunctions();
}
return isInitialized();
}
bool QOpenGLFunctions_4_5_Core::isContextCompatible(QOpenGLContext *context)
{
Q_ASSERT(context);
QSurfaceFormat f = context->format();
const QPair<int, int> v = qMakePair(f.majorVersion(), f.minorVersion());
if (v < qMakePair(4, 5))
return false;
return true;
}
QOpenGLVersionProfile QOpenGLFunctions_4_5_Core::versionProfile()
{
QOpenGLVersionProfile v;
v.setVersion(4, 5);
v.setProfile(QSurfaceFormat::CoreProfile);
return v;
}
QT_END_NAMESPACE

4054
src/gui/opengl/qopenglfunctions_4_5_core.h Normal file
View File

File diff suppressed because it is too large Load Diff

378
src/gui/opengl/qopenglversionfunctions.cpp
View File

@ -338,8 +338,6 @@ QOpenGLFunctions_1_1_CoreBackend::QOpenGLFunctions_1_1_CoreBackend(QOpenGLContex
HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
if (!handle)
handle = GetModuleHandleA("opengl32.dll");
Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glIndexubv"));
Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(GetProcAddress(handle, "glIndexub"));
IsTexture = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glIsTexture"));
GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(GetProcAddress(handle, "glGenTextures"));
DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(GetProcAddress(handle, "glDeleteTextures"));
@ -351,12 +349,9 @@ QOpenGLFunctions_1_1_CoreBackend::QOpenGLFunctions_1_1_CoreBackend(QOpenGLContex
CopyTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint )>(GetProcAddress(handle, "glCopyTexImage2D"));
CopyTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint )>(GetProcAddress(handle, "glCopyTexImage1D"));
PolygonOffset = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glPolygonOffset"));
GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid* *)>(GetProcAddress(handle, "glGetPointerv"));
DrawElements = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *)>(GetProcAddress(handle, "glDrawElements"));
DrawArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei )>(GetProcAddress(handle, "glDrawArrays"));
#else
Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glIndexubv"));
Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(context->getProcAddress("glIndexub"));
IsTexture = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsTexture"));
GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenTextures"));
DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteTextures"));
@ -368,7 +363,6 @@ QOpenGLFunctions_1_1_CoreBackend::QOpenGLFunctions_1_1_CoreBackend(QOpenGLContex
CopyTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint )>(context->getProcAddress("glCopyTexImage2D"));
CopyTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint )>(context->getProcAddress("glCopyTexImage1D"));
PolygonOffset = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glPolygonOffset"));
GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid* *)>(context->getProcAddress("glGetPointerv"));
DrawElements = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *)>(context->getProcAddress("glDrawElements"));
DrawArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei )>(context->getProcAddress("glDrawArrays"));
#endif
@ -474,6 +468,42 @@ QOpenGLFunctions_2_0_CoreBackend::QOpenGLFunctions_2_0_CoreBackend(QOpenGLContex
{
// OpenGL 2.0 core functions
VertexAttribPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexAttribPointer"));
VertexAttrib4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4usv"));
VertexAttrib4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4uiv"));
VertexAttrib4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4ubv"));
VertexAttrib4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4sv"));
VertexAttrib4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib4s"));
VertexAttrib4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4iv"));
VertexAttrib4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib4fv"));
VertexAttrib4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib4f"));
VertexAttrib4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib4dv"));
VertexAttrib4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib4d"));
VertexAttrib4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4bv"));
VertexAttrib4Nusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4Nusv"));
VertexAttrib4Nuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4Nuiv"));
VertexAttrib4Nubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4Nubv"));
VertexAttrib4Nub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLubyte , GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glVertexAttrib4Nub"));
VertexAttrib4Nsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4Nsv"));
VertexAttrib4Niv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4Niv"));
VertexAttrib4Nbv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4Nbv"));
VertexAttrib3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib3sv"));
VertexAttrib3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib3s"));
VertexAttrib3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib3fv"));
VertexAttrib3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib3f"));
VertexAttrib3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib3dv"));
VertexAttrib3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib3d"));
VertexAttrib2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib2sv"));
VertexAttrib2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib2s"));
VertexAttrib2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib2fv"));
VertexAttrib2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib2f"));
VertexAttrib2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib2dv"));
VertexAttrib2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib2d"));
VertexAttrib1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib1sv"));
VertexAttrib1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort )>(context->getProcAddress("glVertexAttrib1s"));
VertexAttrib1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib1fv"));
VertexAttrib1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat )>(context->getProcAddress("glVertexAttrib1f"));
VertexAttrib1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib1dv"));
VertexAttrib1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble )>(context->getProcAddress("glVertexAttrib1d"));
ValidateProgram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glValidateProgram"));
UniformMatrix4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix4fv"));
UniformMatrix3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix3fv"));
@ -606,6 +636,26 @@ QOpenGLFunctions_3_0_CoreBackend::QOpenGLFunctions_3_0_CoreBackend(QOpenGLContex
GetFragDataLocation = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , const GLchar *)>(context->getProcAddress("glGetFragDataLocation"));
BindFragDataLocation = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , const GLchar *)>(context->getProcAddress("glBindFragDataLocation"));
GetUniformuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLuint *)>(context->getProcAddress("glGetUniformuiv"));
VertexAttribI4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttribI4usv"));
VertexAttribI4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttribI4ubv"));
VertexAttribI4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttribI4sv"));
VertexAttribI4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttribI4bv"));
VertexAttribI4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI4uiv"));
VertexAttribI3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI3uiv"));
VertexAttribI2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI2uiv"));
VertexAttribI1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI1uiv"));
VertexAttribI4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI4iv"));
VertexAttribI3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI3iv"));
VertexAttribI2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI2iv"));
VertexAttribI1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI1iv"));
VertexAttribI4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI4ui"));
VertexAttribI3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI3ui"));
VertexAttribI2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI2ui"));
VertexAttribI1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexAttribI1ui"));
VertexAttribI4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI4i"));
VertexAttribI3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI3i"));
VertexAttribI2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint )>(context->getProcAddress("glVertexAttribI2i"));
VertexAttribI1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint )>(context->getProcAddress("glVertexAttribI1i"));
GetVertexAttribIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint *)>(context->getProcAddress("glGetVertexAttribIuiv"));
GetVertexAttribIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexAttribIiv"));
VertexAttribIPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexAttribIPointer"));
@ -662,8 +712,8 @@ QOpenGLFunctions_3_2_CoreBackend::QOpenGLFunctions_3_2_CoreBackend(QOpenGLContex
// OpenGL 3.2 core functions
SampleMaski = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLbitfield )>(context->getProcAddress("glSampleMaski"));
GetMultisamplefv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLfloat *)>(context->getProcAddress("glGetMultisamplefv"));
TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage3DMultisample"));
TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage2DMultisample"));
TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage3DMultisample"));
TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage2DMultisample"));
GetSynciv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsync , GLenum , GLsizei , GLsizei *, GLint *)>(context->getProcAddress("glGetSynciv"));
GetInteger64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint64 *)>(context->getProcAddress("glGetInteger64v"));
WaitSync = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsync , GLbitfield , GLuint64 )>(context->getProcAddress("glWaitSync"));
@ -699,36 +749,6 @@ QOpenGLFunctions_3_3_CoreBackend::QOpenGLFunctions_3_3_CoreBackend(QOpenGLContex
VertexAttribP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribP2ui"));
VertexAttribP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , const GLuint *)>(context->getProcAddress("glVertexAttribP1uiv"));
VertexAttribP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribP1ui"));
SecondaryColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glSecondaryColorP3uiv"));
SecondaryColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glSecondaryColorP3ui"));
ColorP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP4uiv"));
ColorP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP4ui"));
ColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP3uiv"));
ColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP3ui"));
NormalP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glNormalP3uiv"));
NormalP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glNormalP3ui"));
MultiTexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP4uiv"));
MultiTexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP4ui"));
MultiTexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP3uiv"));
MultiTexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP3ui"));
MultiTexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP2uiv"));
MultiTexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP2ui"));
MultiTexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP1uiv"));
MultiTexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP1ui"));
TexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP4uiv"));
TexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP4ui"));
TexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP3uiv"));
TexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP3ui"));
TexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP2uiv"));
TexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP2ui"));
TexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP1uiv"));
TexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP1ui"));
VertexP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP4uiv"));
VertexP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP4ui"));
VertexP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP3uiv"));
VertexP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP3ui"));
VertexP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP2uiv"));
VertexP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP2ui"));
GetQueryObjectui64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint64 *)>(context->getProcAddress("glGetQueryObjectui64v"));
GetQueryObjecti64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint64 *)>(context->getProcAddress("glGetQueryObjecti64v"));
QueryCounter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glQueryCounter"));
@ -943,6 +963,16 @@ QOpenGLFunctions_4_3_CoreBackend::QOpenGLFunctions_4_3_CoreBackend(QOpenGLContex
: QOpenGLVersionFunctionsBackend(context)
{
// OpenGL 4.3 core functions
GetObjectPtrLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const void *, GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetObjectPtrLabel"));
ObjectPtrLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const void *, GLsizei , const GLchar *)>(context->getProcAddress("glObjectPtrLabel"));
GetObjectLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetObjectLabel"));
ObjectLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLchar *)>(context->getProcAddress("glObjectLabel"));
PopDebugGroup = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopDebugGroup"));
PushDebugGroup = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLchar *)>(context->getProcAddress("glPushDebugGroup"));
GetDebugMessageLog = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum *, GLenum *, GLuint *, GLenum *, GLsizei *, GLchar *)>(context->getProcAddress("glGetDebugMessageLog"));
DebugMessageCallback = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLDEBUGPROC , const void *)>(context->getProcAddress("glDebugMessageCallback"));
DebugMessageInsert = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLenum , GLsizei , const GLchar *)>(context->getProcAddress("glDebugMessageInsert"));
DebugMessageControl = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , const GLuint *, GLboolean )>(context->getProcAddress("glDebugMessageControl"));
TexStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage3DMultisample"));
TexStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage2DMultisample"));
TexBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress("glTexBufferRange"));
@ -984,6 +1014,145 @@ QOpenGLVersionStatus QOpenGLFunctions_4_3_CoreBackend::versionStatus()
return QOpenGLVersionStatus(4, 3, QOpenGLVersionStatus::CoreStatus);
}
QOpenGLFunctions_4_4_CoreBackend::QOpenGLFunctions_4_4_CoreBackend(QOpenGLContext *context)
: QOpenGLVersionFunctionsBackend(context)
{
// OpenGL 4.4 core functions
BindVertexBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *, const GLintptr *, const GLsizei *)>(context->getProcAddress("glBindVertexBuffers"));
BindImageTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindImageTextures"));
BindSamplers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindSamplers"));
BindTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindTextures"));
BindBuffersRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLuint *, const GLintptr *, const GLsizeiptr *)>(context->getProcAddress("glBindBuffersRange"));
BindBuffersBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindBuffersBase"));
ClearTexSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glClearTexSubImage"));
ClearTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLenum , const void *)>(context->getProcAddress("glClearTexImage"));
BufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizeiptr , const void *, GLbitfield )>(context->getProcAddress("glBufferStorage"));
}
QOpenGLVersionStatus QOpenGLFunctions_4_4_CoreBackend::versionStatus()
{
return QOpenGLVersionStatus(4, 4, QOpenGLVersionStatus::CoreStatus);
}
QOpenGLFunctions_4_5_CoreBackend::QOpenGLFunctions_4_5_CoreBackend(QOpenGLContext *context)
: QOpenGLVersionFunctionsBackend(context)
{
// OpenGL 4.5 core functions
TextureBarrier = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glTextureBarrier"));
ReadnPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glReadnPixels"));
GetnUniformuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLuint *)>(context->getProcAddress("glGetnUniformuiv"));
GetnUniformiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLint *)>(context->getProcAddress("glGetnUniformiv"));
GetnUniformfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLfloat *)>(context->getProcAddress("glGetnUniformfv"));
GetnUniformdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLdouble *)>(context->getProcAddress("glGetnUniformdv"));
GetnTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnTexImage"));
GetnCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei , void *)>(context->getProcAddress("glGetnCompressedTexImage"));
GetGraphicsResetStatus = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glGetGraphicsResetStatus"));
GetCompressedTextureSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLsizei , void *)>(context->getProcAddress("glGetCompressedTextureSubImage"));
GetTextureSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetTextureSubImage"));
MemoryBarrierByRegion = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glMemoryBarrierByRegion"));
CreateQueries = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLuint *)>(context->getProcAddress("glCreateQueries"));
CreateProgramPipelines = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateProgramPipelines"));
CreateSamplers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateSamplers"));
GetVertexArrayIndexed64iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLenum , GLint64 *)>(context->getProcAddress("glGetVertexArrayIndexed64iv"));
GetVertexArrayIndexediv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexArrayIndexediv"));
GetVertexArrayiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexArrayiv"));
VertexArrayBindingDivisor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexArrayBindingDivisor"));
VertexArrayAttribLFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLenum , GLuint )>(context->getProcAddress("glVertexArrayAttribLFormat"));
VertexArrayAttribIFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLenum , GLuint )>(context->getProcAddress("glVertexArrayAttribIFormat"));
VertexArrayAttribFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexArrayAttribFormat"));
VertexArrayAttribBinding = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexArrayAttribBinding"));
VertexArrayVertexBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , const GLuint *, const GLintptr *, const GLsizei *)>(context->getProcAddress("glVertexArrayVertexBuffers"));
VertexArrayVertexBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glVertexArrayVertexBuffer"));
VertexArrayElementBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexArrayElementBuffer"));
EnableVertexArrayAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glEnableVertexArrayAttrib"));
DisableVertexArrayAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glDisableVertexArrayAttrib"));
CreateVertexArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateVertexArrays"));
GetTextureParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetTextureParameteriv"));
GetTextureParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint *)>(context->getProcAddress("glGetTextureParameterIuiv"));
GetTextureParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetTextureParameterIiv"));
GetTextureParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat *)>(context->getProcAddress("glGetTextureParameterfv"));
GetTextureLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLint *)>(context->getProcAddress("glGetTextureLevelParameteriv"));
GetTextureLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLfloat *)>(context->getProcAddress("glGetTextureLevelParameterfv"));
GetCompressedTextureImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , void *)>(context->getProcAddress("glGetCompressedTextureImage"));
GetTextureImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetTextureImage"));
BindTextureUnit = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glBindTextureUnit"));
GenerateTextureMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glGenerateTextureMipmap"));
TextureParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLint *)>(context->getProcAddress("glTextureParameteriv"));
TextureParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLuint *)>(context->getProcAddress("glTextureParameterIuiv"));
TextureParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLint *)>(context->getProcAddress("glTextureParameterIiv"));
TextureParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint )>(context->getProcAddress("glTextureParameteri"));
TextureParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLfloat *)>(context->getProcAddress("glTextureParameterfv"));
TextureParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat )>(context->getProcAddress("glTextureParameterf"));
CopyTextureSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyTextureSubImage3D"));
CopyTextureSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyTextureSubImage2D"));
CopyTextureSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei )>(context->getProcAddress("glCopyTextureSubImage1D"));
CompressedTextureSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const void *)>(context->getProcAddress("glCompressedTextureSubImage3D"));
CompressedTextureSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const void *)>(context->getProcAddress("glCompressedTextureSubImage2D"));
CompressedTextureSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLsizei , GLenum , GLsizei , const void *)>(context->getProcAddress("glCompressedTextureSubImage1D"));
TextureSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glTextureSubImage3D"));
TextureSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glTextureSubImage2D"));
TextureSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glTextureSubImage1D"));
TextureStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage3DMultisample"));
TextureStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage2DMultisample"));
TextureStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage3D"));
TextureStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage2D"));
TextureStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTextureStorage1D"));
TextureBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glTextureBufferRange"));
TextureBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint )>(context->getProcAddress("glTextureBuffer"));
CreateTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLuint *)>(context->getProcAddress("glCreateTextures"));
GetNamedRenderbufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetNamedRenderbufferParameteriv"));
NamedRenderbufferStorageMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glNamedRenderbufferStorageMultisample"));
NamedRenderbufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glNamedRenderbufferStorage"));
CreateRenderbuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateRenderbuffers"));
GetNamedFramebufferAttachmentParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint *)>(context->getProcAddress("glGetNamedFramebufferAttachmentParameteriv"));
GetNamedFramebufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetNamedFramebufferParameteriv"));
CheckNamedFramebufferStatus = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glCheckNamedFramebufferStatus"));
BlitNamedFramebuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum )>(context->getProcAddress("glBlitNamedFramebuffer"));
ClearNamedFramebufferfi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat , GLint )>(context->getProcAddress("glClearNamedFramebufferfi"));
ClearNamedFramebufferfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , const GLfloat *)>(context->getProcAddress("glClearNamedFramebufferfv"));
ClearNamedFramebufferuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , const GLuint *)>(context->getProcAddress("glClearNamedFramebufferuiv"));
ClearNamedFramebufferiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , const GLint *)>(context->getProcAddress("glClearNamedFramebufferiv"));
InvalidateNamedFramebufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLenum *, GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glInvalidateNamedFramebufferSubData"));
InvalidateNamedFramebufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLenum *)>(context->getProcAddress("glInvalidateNamedFramebufferData"));
NamedFramebufferReadBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glNamedFramebufferReadBuffer"));
NamedFramebufferDrawBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLenum *)>(context->getProcAddress("glNamedFramebufferDrawBuffers"));
NamedFramebufferDrawBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glNamedFramebufferDrawBuffer"));
NamedFramebufferTextureLayer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint , GLint )>(context->getProcAddress("glNamedFramebufferTextureLayer"));
NamedFramebufferTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint )>(context->getProcAddress("glNamedFramebufferTexture"));
NamedFramebufferParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint )>(context->getProcAddress("glNamedFramebufferParameteri"));
NamedFramebufferRenderbuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLuint )>(context->getProcAddress("glNamedFramebufferRenderbuffer"));
CreateFramebuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateFramebuffers"));
GetNamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei , void *)>(context->getProcAddress("glGetNamedBufferSubData"));
GetNamedBufferPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , void * *)>(context->getProcAddress("glGetNamedBufferPointerv"));
GetNamedBufferParameteri64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint64 *)>(context->getProcAddress("glGetNamedBufferParameteri64v"));
GetNamedBufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetNamedBufferParameteriv"));
FlushMappedNamedBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei )>(context->getProcAddress("glFlushMappedNamedBufferRange"));
UnmapNamedBuffer = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glUnmapNamedBuffer"));
MapNamedBufferRange = reinterpret_cast<void * (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei , GLbitfield )>(context->getProcAddress("glMapNamedBufferRange"));
MapNamedBuffer = reinterpret_cast<void * (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glMapNamedBuffer"));
ClearNamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLintptr , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glClearNamedBufferSubData"));
ClearNamedBufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLenum , const void *)>(context->getProcAddress("glClearNamedBufferData"));
CopyNamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLintptr , GLintptr , GLsizei )>(context->getProcAddress("glCopyNamedBufferSubData"));
NamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei , const void *)>(context->getProcAddress("glNamedBufferSubData"));
NamedBufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const void *, GLenum )>(context->getProcAddress("glNamedBufferData"));
NamedBufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const void *, GLbitfield )>(context->getProcAddress("glNamedBufferStorage"));
CreateBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateBuffers"));
GetTransformFeedbacki64_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint64 *)>(context->getProcAddress("glGetTransformFeedbacki64_v"));
GetTransformFeedbacki_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint *)>(context->getProcAddress("glGetTransformFeedbacki_v"));
GetTransformFeedbackiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetTransformFeedbackiv"));
TransformFeedbackBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glTransformFeedbackBufferRange"));
TransformFeedbackBufferBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glTransformFeedbackBufferBase"));
CreateTransformFeedbacks = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateTransformFeedbacks"));
ClipControl = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glClipControl"));
}
QOpenGLVersionStatus QOpenGLFunctions_4_5_CoreBackend::versionStatus()
{
return QOpenGLVersionStatus(4, 5, QOpenGLVersionStatus::CoreStatus);
}
QOpenGLFunctions_1_0_DeprecatedBackend::QOpenGLFunctions_1_0_DeprecatedBackend(QOpenGLContext *context)
: QOpenGLVersionFunctionsBackend(context)
{
@ -1028,9 +1197,9 @@ QOpenGLFunctions_1_0_DeprecatedBackend::QOpenGLFunctions_1_0_DeprecatedBackend(Q
GetClipPlane = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble *)>(GetProcAddress(handle, "glGetClipPlane"));
DrawPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, "glDrawPixels"));
CopyPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum )>(GetProcAddress(handle, "glCopyPixels"));
PixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLushort *)>(GetProcAddress(handle, "glPixelMapusv"));
PixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLuint *)>(GetProcAddress(handle, "glPixelMapuiv"));
PixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLfloat *)>(GetProcAddress(handle, "glPixelMapfv"));
PixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLushort *)>(GetProcAddress(handle, "glPixelMapusv"));
PixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLuint *)>(GetProcAddress(handle, "glPixelMapuiv"));
PixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLfloat *)>(GetProcAddress(handle, "glPixelMapfv"));
PixelTransferi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, "glPixelTransferi"));
PixelTransferf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glPixelTransferf"));
PixelZoom = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glPixelZoom"));
@ -1287,9 +1456,9 @@ QOpenGLFunctions_1_0_DeprecatedBackend::QOpenGLFunctions_1_0_DeprecatedBackend(Q
GetClipPlane = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble *)>(context->getProcAddress("glGetClipPlane"));
DrawPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glDrawPixels"));
CopyPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum )>(context->getProcAddress("glCopyPixels"));
PixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLushort *)>(context->getProcAddress("glPixelMapusv"));
PixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLuint *)>(context->getProcAddress("glPixelMapuiv"));
PixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLfloat *)>(context->getProcAddress("glPixelMapfv"));
PixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLushort *)>(context->getProcAddress("glPixelMapusv"));
PixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLuint *)>(context->getProcAddress("glPixelMapuiv"));
PixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLfloat *)>(context->getProcAddress("glPixelMapfv"));
PixelTransferi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glPixelTransferi"));
PixelTransferf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glPixelTransferf"));
PixelZoom = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glPixelZoom"));
@ -1528,12 +1697,15 @@ QOpenGLFunctions_1_1_DeprecatedBackend::QOpenGLFunctions_1_1_DeprecatedBackend(Q
handle = GetModuleHandleA("opengl32.dll");
PushClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(GetProcAddress(handle, "glPushClientAttrib"));
PopClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glPopClientAttrib"));
Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glIndexubv"));
Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(GetProcAddress(handle, "glIndexub"));
PrioritizeTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, const GLfloat *)>(GetProcAddress(handle, "glPrioritizeTextures"));
AreTexturesResident = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, GLboolean *)>(GetProcAddress(handle, "glAreTexturesResident"));
VertexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glVertexPointer"));
TexCoordPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glTexCoordPointer"));
NormalPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glNormalPointer"));
InterleavedArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glInterleavedArrays"));
GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid * *)>(GetProcAddress(handle, "glGetPointerv"));
IndexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glIndexPointer"));
EnableClientState = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glEnableClientState"));
EdgeFlagPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLvoid *)>(GetProcAddress(handle, "glEdgeFlagPointer"));
@ -1543,12 +1715,15 @@ QOpenGLFunctions_1_1_DeprecatedBackend::QOpenGLFunctions_1_1_DeprecatedBackend(Q
#else
PushClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glPushClientAttrib"));
PopClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopClientAttrib"));
Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glIndexubv"));
Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(context->getProcAddress("glIndexub"));
PrioritizeTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, const GLfloat *)>(context->getProcAddress("glPrioritizeTextures"));
AreTexturesResident = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, GLboolean *)>(context->getProcAddress("glAreTexturesResident"));
VertexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexPointer"));
TexCoordPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glTexCoordPointer"));
NormalPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glNormalPointer"));
InterleavedArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glInterleavedArrays"));
GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid * *)>(context->getProcAddress("glGetPointerv"));
IndexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glIndexPointer"));
EnableClientState = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glEnableClientState"));
EdgeFlagPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLvoid *)>(context->getProcAddress("glEdgeFlagPointer"));
@ -1707,87 +1882,72 @@ QOpenGLVersionStatus QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus()
return QOpenGLVersionStatus(1, 4, QOpenGLVersionStatus::DeprecatedStatus);
}
QOpenGLFunctions_2_0_DeprecatedBackend::QOpenGLFunctions_2_0_DeprecatedBackend(QOpenGLContext *context)
QOpenGLFunctions_3_3_DeprecatedBackend::QOpenGLFunctions_3_3_DeprecatedBackend(QOpenGLContext *context)
: QOpenGLVersionFunctionsBackend(context)
{
// OpenGL 2.0 deprecated functions
VertexAttrib4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4usv"));
VertexAttrib4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4uiv"));
VertexAttrib4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4ubv"));
VertexAttrib4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4sv"));
VertexAttrib4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib4s"));
VertexAttrib4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4iv"));
VertexAttrib4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib4fv"));
VertexAttrib4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib4f"));
VertexAttrib4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib4dv"));
VertexAttrib4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib4d"));
VertexAttrib4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4bv"));
VertexAttrib4Nusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4Nusv"));
VertexAttrib4Nuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4Nuiv"));
VertexAttrib4Nubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4Nubv"));
VertexAttrib4Nub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLubyte , GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glVertexAttrib4Nub"));
VertexAttrib4Nsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4Nsv"));
VertexAttrib4Niv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4Niv"));
VertexAttrib4Nbv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4Nbv"));
VertexAttrib3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib3sv"));
VertexAttrib3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib3s"));
VertexAttrib3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib3fv"));
VertexAttrib3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib3f"));
VertexAttrib3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib3dv"));
VertexAttrib3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib3d"));
VertexAttrib2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib2sv"));
VertexAttrib2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib2s"));
VertexAttrib2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib2fv"));
VertexAttrib2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib2f"));
VertexAttrib2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib2dv"));
VertexAttrib2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib2d"));
VertexAttrib1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib1sv"));
VertexAttrib1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort )>(context->getProcAddress("glVertexAttrib1s"));
VertexAttrib1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib1fv"));
VertexAttrib1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat )>(context->getProcAddress("glVertexAttrib1f"));
VertexAttrib1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib1dv"));
VertexAttrib1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble )>(context->getProcAddress("glVertexAttrib1d"));
// OpenGL 3.3 deprecated functions
SecondaryColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glSecondaryColorP3uiv"));
SecondaryColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glSecondaryColorP3ui"));
ColorP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP4uiv"));
ColorP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP4ui"));
ColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP3uiv"));
ColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP3ui"));
NormalP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glNormalP3uiv"));
NormalP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glNormalP3ui"));
MultiTexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP4uiv"));
MultiTexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP4ui"));
MultiTexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP3uiv"));
MultiTexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP3ui"));
MultiTexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP2uiv"));
MultiTexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP2ui"));
MultiTexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP1uiv"));
MultiTexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP1ui"));
TexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP4uiv"));
TexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP4ui"));
TexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP3uiv"));
TexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP3ui"));
TexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP2uiv"));
TexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP2ui"));
TexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP1uiv"));
TexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP1ui"));
VertexP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP4uiv"));
VertexP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP4ui"));
VertexP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP3uiv"));
VertexP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP3ui"));
VertexP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP2uiv"));
VertexP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP2ui"));
}
QOpenGLVersionStatus QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus()
QOpenGLVersionStatus QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus()
{
return QOpenGLVersionStatus(2, 0, QOpenGLVersionStatus::DeprecatedStatus);
return QOpenGLVersionStatus(3, 3, QOpenGLVersionStatus::DeprecatedStatus);
}
QOpenGLFunctions_3_0_DeprecatedBackend::QOpenGLFunctions_3_0_DeprecatedBackend(QOpenGLContext *context)
QOpenGLFunctions_4_5_DeprecatedBackend::QOpenGLFunctions_4_5_DeprecatedBackend(QOpenGLContext *context)
: QOpenGLVersionFunctionsBackend(context)
{
// OpenGL 3.0 deprecated functions
VertexAttribI4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttribI4usv"));
VertexAttribI4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttribI4ubv"));
VertexAttribI4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttribI4sv"));
VertexAttribI4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttribI4bv"));
VertexAttribI4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI4uiv"));
VertexAttribI3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI3uiv"));
VertexAttribI2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI2uiv"));
VertexAttribI1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI1uiv"));
VertexAttribI4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI4iv"));
VertexAttribI3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI3iv"));
VertexAttribI2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI2iv"));
VertexAttribI1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI1iv"));
VertexAttribI4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI4ui"));
VertexAttribI3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI3ui"));
VertexAttribI2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI2ui"));
VertexAttribI1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexAttribI1ui"));
VertexAttribI4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI4i"));
VertexAttribI3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI3i"));
VertexAttribI2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint )>(context->getProcAddress("glVertexAttribI2i"));
VertexAttribI1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint )>(context->getProcAddress("glVertexAttribI1i"));
// OpenGL 4.5 deprecated functions
GetnMinmax = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnMinmax"));
GetnHistogram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnHistogram"));
GetnSeparableFilter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , void *, GLsizei , void *, void *)>(context->getProcAddress("glGetnSeparableFilter"));
GetnConvolutionFilter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnConvolutionFilter"));
GetnColorTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnColorTable"));
GetnPolygonStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLubyte *)>(context->getProcAddress("glGetnPolygonStipple"));
GetnPixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLushort *)>(context->getProcAddress("glGetnPixelMapusv"));
GetnPixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLuint *)>(context->getProcAddress("glGetnPixelMapuiv"));
GetnPixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLfloat *)>(context->getProcAddress("glGetnPixelMapfv"));
GetnMapiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLint *)>(context->getProcAddress("glGetnMapiv"));
GetnMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLfloat *)>(context->getProcAddress("glGetnMapfv"));
GetnMapdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLdouble *)>(context->getProcAddress("glGetnMapdv"));
}
QOpenGLVersionStatus QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus()
QOpenGLVersionStatus QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus()
{
return QOpenGLVersionStatus(3, 0, QOpenGLVersionStatus::DeprecatedStatus);
return QOpenGLVersionStatus(4, 5, QOpenGLVersionStatus::DeprecatedStatus);
}
#else
// No backends for OpenGL ES 2

444
src/gui/opengl/qopenglversionfunctions.h
View File

@ -61,6 +61,10 @@ class QOpenGLContext;
#pragma qt_sync_stop_processing
#endif
#define QOPENGL_DEPRECATEDFUNCTION \
qFatal("This function was erroneously included in previous versions of Qt and is here only for binary compatibility. " \
"If you need to use this function, please use a legacy OpenGL version or a Compatibility profile.")
struct QOpenGLVersionStatus
{
enum OpenGLStatus {
@ -169,13 +173,13 @@ public:
void (QOPENGLF_APIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
const GLubyte * (QOPENGLF_APIENTRYP GetString)(GLenum name);
void (QOPENGLF_APIENTRYP GetIntegerv)(GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetFloatv)(GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetIntegerv)(GLenum pname, GLint *data);
void (QOPENGLF_APIENTRYP GetFloatv)(GLenum pname, GLfloat *data);
GLenum (QOPENGLF_APIENTRYP GetError)();
void (QOPENGLF_APIENTRYP GetDoublev)(GLenum pname, GLdouble *params);
void (QOPENGLF_APIENTRYP GetBooleanv)(GLenum pname, GLboolean *params);
void (QOPENGLF_APIENTRYP GetDoublev)(GLenum pname, GLdouble *data);
void (QOPENGLF_APIENTRYP GetBooleanv)(GLenum pname, GLboolean *data);
void (QOPENGLF_APIENTRYP ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
void (QOPENGLF_APIENTRYP ReadBuffer)(GLenum mode);
void (QOPENGLF_APIENTRYP ReadBuffer)(GLenum src);
void (QOPENGLF_APIENTRYP PixelStorei)(GLenum pname, GLint param);
void (QOPENGLF_APIENTRYP PixelStoref)(GLenum pname, GLfloat param);
void (QOPENGLF_APIENTRYP DepthFunc)(GLenum func);
@ -194,7 +198,7 @@ public:
void (QOPENGLF_APIENTRYP ClearStencil)(GLint s);
void (QOPENGLF_APIENTRYP ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
void (QOPENGLF_APIENTRYP Clear)(GLbitfield mask);
void (QOPENGLF_APIENTRYP DrawBuffer)(GLenum mode);
void (QOPENGLF_APIENTRYP DrawBuffer)(GLenum buf);
void (QOPENGLF_APIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
void (QOPENGLF_APIENTRYP TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
void (QOPENGLF_APIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint *params);
@ -219,8 +223,6 @@ public:
static QOpenGLVersionStatus versionStatus();
// OpenGL 1.1 core functions
void (QOPENGLF_APIENTRYP Indexubv)(const GLubyte *c);
void (QOPENGLF_APIENTRYP Indexub)(GLubyte c);
GLboolean (QOPENGLF_APIENTRYP IsTexture)(GLuint texture);
void (QOPENGLF_APIENTRYP GenTextures)(GLsizei n, GLuint *textures);
void (QOPENGLF_APIENTRYP DeleteTextures)(GLsizei n, const GLuint *textures);
@ -232,7 +234,6 @@ public:
void (QOPENGLF_APIENTRYP CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
void (QOPENGLF_APIENTRYP CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
void (QOPENGLF_APIENTRYP PolygonOffset)(GLfloat factor, GLfloat units);
void (QOPENGLF_APIENTRYP GetPointerv)(GLenum pname, GLvoid* *params);
void (QOPENGLF_APIENTRYP DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
void (QOPENGLF_APIENTRYP DrawArrays)(GLenum mode, GLint first, GLsizei count);
@ -332,6 +333,42 @@ public:
// OpenGL 2.0 core functions
void (QOPENGLF_APIENTRYP VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
void (QOPENGLF_APIENTRYP VertexAttrib4usv)(GLuint index, const GLushort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4ubv)(GLuint index, const GLubyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib4sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
void (QOPENGLF_APIENTRYP VertexAttrib4iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void (QOPENGLF_APIENTRYP VertexAttrib4dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void (QOPENGLF_APIENTRYP VertexAttrib4bv)(GLuint index, const GLbyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nusv)(GLuint index, const GLushort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nuiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nubv)(GLuint index, const GLubyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
void (QOPENGLF_APIENTRYP VertexAttrib4Nsv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Niv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nbv)(GLuint index, const GLbyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib3sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z);
void (QOPENGLF_APIENTRYP VertexAttrib3fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
void (QOPENGLF_APIENTRYP VertexAttrib3dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
void (QOPENGLF_APIENTRYP VertexAttrib2sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib2s)(GLuint index, GLshort x, GLshort y);
void (QOPENGLF_APIENTRYP VertexAttrib2fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib2f)(GLuint index, GLfloat x, GLfloat y);
void (QOPENGLF_APIENTRYP VertexAttrib2dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y);
void (QOPENGLF_APIENTRYP VertexAttrib1sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib1s)(GLuint index, GLshort x);
void (QOPENGLF_APIENTRYP VertexAttrib1fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib1f)(GLuint index, GLfloat x);
void (QOPENGLF_APIENTRYP VertexAttrib1dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib1d)(GLuint index, GLdouble x);
void (QOPENGLF_APIENTRYP ValidateProgram)(GLuint program);
void (QOPENGLF_APIENTRYP UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
void (QOPENGLF_APIENTRYP UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
@ -370,7 +407,7 @@ public:
void (QOPENGLF_APIENTRYP GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
void (QOPENGLF_APIENTRYP GetProgramiv)(GLuint program, GLenum pname, GLint *params);
GLint (QOPENGLF_APIENTRYP GetAttribLocation)(GLuint program, const GLchar *name);
void (QOPENGLF_APIENTRYP GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
void (QOPENGLF_APIENTRYP GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
void (QOPENGLF_APIENTRYP GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
void (QOPENGLF_APIENTRYP GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
void (QOPENGLF_APIENTRYP EnableVertexAttribArray)(GLuint index);
@ -462,6 +499,26 @@ public:
GLint (QOPENGLF_APIENTRYP GetFragDataLocation)(GLuint program, const GLchar *name);
void (QOPENGLF_APIENTRYP BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name);
void (QOPENGLF_APIENTRYP GetUniformuiv)(GLuint program, GLint location, GLuint *params);
void (QOPENGLF_APIENTRYP VertexAttribI4usv)(GLuint index, const GLushort *v);
void (QOPENGLF_APIENTRYP VertexAttribI4ubv)(GLuint index, const GLubyte *v);
void (QOPENGLF_APIENTRYP VertexAttribI4sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttribI4bv)(GLuint index, const GLbyte *v);
void (QOPENGLF_APIENTRYP VertexAttribI4uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI3uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI2uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI1uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI4iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI3iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI2iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI1iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
void (QOPENGLF_APIENTRYP VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
void (QOPENGLF_APIENTRYP VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
void (QOPENGLF_APIENTRYP VertexAttribI1ui)(GLuint index, GLuint x);
void (QOPENGLF_APIENTRYP VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
void (QOPENGLF_APIENTRYP VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
void (QOPENGLF_APIENTRYP VertexAttribI2i)(GLuint index, GLint x, GLint y);
void (QOPENGLF_APIENTRYP VertexAttribI1i)(GLuint index, GLint x);
void (QOPENGLF_APIENTRYP GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
void (QOPENGLF_APIENTRYP GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
@ -514,12 +571,12 @@ public:
static QOpenGLVersionStatus versionStatus();
// OpenGL 3.2 core functions
void (QOPENGLF_APIENTRYP SampleMaski)(GLuint index, GLbitfield mask);
void (QOPENGLF_APIENTRYP SampleMaski)(GLuint maskNumber, GLbitfield mask);
void (QOPENGLF_APIENTRYP GetMultisamplefv)(GLenum pname, GLuint index, GLfloat *val);
void (QOPENGLF_APIENTRYP TexImage3DMultisample)(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TexImage2DMultisample)(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TexImage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TexImage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
void (QOPENGLF_APIENTRYP GetInteger64v)(GLenum pname, GLint64 *params);
void (QOPENGLF_APIENTRYP GetInteger64v)(GLenum pname, GLint64 *data);
void (QOPENGLF_APIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
GLenum (QOPENGLF_APIENTRYP ClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
void (QOPENGLF_APIENTRYP DeleteSync)(GLsync sync);
@ -552,36 +609,6 @@ public:
void (QOPENGLF_APIENTRYP VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
void (QOPENGLF_APIENTRYP VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
void (QOPENGLF_APIENTRYP SecondaryColorP3uiv)(GLenum type, const GLuint *color);
void (QOPENGLF_APIENTRYP SecondaryColorP3ui)(GLenum type, GLuint color);
void (QOPENGLF_APIENTRYP ColorP4uiv)(GLenum type, const GLuint *color);
void (QOPENGLF_APIENTRYP ColorP4ui)(GLenum type, GLuint color);
void (QOPENGLF_APIENTRYP ColorP3uiv)(GLenum type, const GLuint *color);
void (QOPENGLF_APIENTRYP ColorP3ui)(GLenum type, GLuint color);
void (QOPENGLF_APIENTRYP NormalP3uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP NormalP3ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP4uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP4ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP3uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP3ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP2uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP2ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP1uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP1ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP4uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP4ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP3uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP3ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP2uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP2ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP1uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP1ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP VertexP4uiv)(GLenum type, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexP4ui)(GLenum type, GLuint value);
void (QOPENGLF_APIENTRYP VertexP3uiv)(GLenum type, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexP3ui)(GLenum type, GLuint value);
void (QOPENGLF_APIENTRYP VertexP2uiv)(GLenum type, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexP2ui)(GLenum type, GLuint value);
void (QOPENGLF_APIENTRYP GetQueryObjectui64v)(GLuint id, GLenum pname, GLuint64 *params);
void (QOPENGLF_APIENTRYP GetQueryObjecti64v)(GLuint id, GLenum pname, GLint64 *params);
void (QOPENGLF_APIENTRYP QueryCounter)(GLuint id, GLenum target);
@ -792,6 +819,16 @@ public:
static QOpenGLVersionStatus versionStatus();
// OpenGL 4.3 core functions
void (QOPENGLF_APIENTRYP GetObjectPtrLabel)(const GLvoid *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
void (QOPENGLF_APIENTRYP ObjectPtrLabel)(const GLvoid *ptr, GLsizei length, const GLchar *label);
void (QOPENGLF_APIENTRYP GetObjectLabel)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
void (QOPENGLF_APIENTRYP ObjectLabel)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
void (QOPENGLF_APIENTRYP PopDebugGroup)();
void (QOPENGLF_APIENTRYP PushDebugGroup)(GLenum source, GLuint id, GLsizei length, const GLchar *message);
GLuint (QOPENGLF_APIENTRYP GetDebugMessageLog)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
void (QOPENGLF_APIENTRYP DebugMessageCallback)(GLDEBUGPROC callback, const GLvoid *userParam);
void (QOPENGLF_APIENTRYP DebugMessageInsert)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
void (QOPENGLF_APIENTRYP DebugMessageControl)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
void (QOPENGLF_APIENTRYP TexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TexBufferRange)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
@ -828,6 +865,143 @@ public:
};
class QOpenGLFunctions_4_4_CoreBackend : public QOpenGLVersionFunctionsBackend
{
public:
QOpenGLFunctions_4_4_CoreBackend(QOpenGLContext *context);
static QOpenGLVersionStatus versionStatus();
// OpenGL 4.4 core functions
void (QOPENGLF_APIENTRYP BindVertexBuffers)(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
void (QOPENGLF_APIENTRYP BindImageTextures)(GLuint first, GLsizei count, const GLuint *textures);
void (QOPENGLF_APIENTRYP BindSamplers)(GLuint first, GLsizei count, const GLuint *samplers);
void (QOPENGLF_APIENTRYP BindTextures)(GLuint first, GLsizei count, const GLuint *textures);
void (QOPENGLF_APIENTRYP BindBuffersRange)(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
void (QOPENGLF_APIENTRYP BindBuffersBase)(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
void (QOPENGLF_APIENTRYP ClearTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
void (QOPENGLF_APIENTRYP ClearTexImage)(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
void (QOPENGLF_APIENTRYP BufferStorage)(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
};
class QOpenGLFunctions_4_5_CoreBackend : public QOpenGLVersionFunctionsBackend
{
public:
QOpenGLFunctions_4_5_CoreBackend(QOpenGLContext *context);
static QOpenGLVersionStatus versionStatus();
// OpenGL 4.5 core functions
void (QOPENGLF_APIENTRYP TextureBarrier)();
void (QOPENGLF_APIENTRYP ReadnPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
void (QOPENGLF_APIENTRYP GetnUniformuiv)(GLuint program, GLint location, GLsizei bufSize, GLuint *params);
void (QOPENGLF_APIENTRYP GetnUniformiv)(GLuint program, GLint location, GLsizei bufSize, GLint *params);
void (QOPENGLF_APIENTRYP GetnUniformfv)(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
void (QOPENGLF_APIENTRYP GetnUniformdv)(GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
void (QOPENGLF_APIENTRYP GetnTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
void (QOPENGLF_APIENTRYP GetnCompressedTexImage)(GLenum target, GLint lod, GLsizei bufSize, void *pixels);
GLenum (QOPENGLF_APIENTRYP GetGraphicsResetStatus)();
void (QOPENGLF_APIENTRYP GetCompressedTextureSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels);
void (QOPENGLF_APIENTRYP GetTextureSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
void (QOPENGLF_APIENTRYP MemoryBarrierByRegion)(GLbitfield barriers);
void (QOPENGLF_APIENTRYP CreateQueries)(GLenum target, GLsizei n, GLuint *ids);
void (QOPENGLF_APIENTRYP CreateProgramPipelines)(GLsizei n, GLuint *pipelines);
void (QOPENGLF_APIENTRYP CreateSamplers)(GLsizei n, GLuint *samplers);
void (QOPENGLF_APIENTRYP GetVertexArrayIndexed64iv)(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param);
void (QOPENGLF_APIENTRYP GetVertexArrayIndexediv)(GLuint vaobj, GLuint index, GLenum pname, GLint *param);
void (QOPENGLF_APIENTRYP GetVertexArrayiv)(GLuint vaobj, GLenum pname, GLint *param);
void (QOPENGLF_APIENTRYP VertexArrayBindingDivisor)(GLuint vaobj, GLuint bindingindex, GLuint divisor);
void (QOPENGLF_APIENTRYP VertexArrayAttribLFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
void (QOPENGLF_APIENTRYP VertexArrayAttribIFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
void (QOPENGLF_APIENTRYP VertexArrayAttribFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
void (QOPENGLF_APIENTRYP VertexArrayAttribBinding)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
void (QOPENGLF_APIENTRYP VertexArrayVertexBuffers)(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
void (QOPENGLF_APIENTRYP VertexArrayVertexBuffer)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
void (QOPENGLF_APIENTRYP VertexArrayElementBuffer)(GLuint vaobj, GLuint buffer);
void (QOPENGLF_APIENTRYP EnableVertexArrayAttrib)(GLuint vaobj, GLuint index);
void (QOPENGLF_APIENTRYP DisableVertexArrayAttrib)(GLuint vaobj, GLuint index);
void (QOPENGLF_APIENTRYP CreateVertexArrays)(GLsizei n, GLuint *arrays);
void (QOPENGLF_APIENTRYP GetTextureParameteriv)(GLuint texture, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetTextureParameterIuiv)(GLuint texture, GLenum pname, GLuint *params);
void (QOPENGLF_APIENTRYP GetTextureParameterIiv)(GLuint texture, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetTextureParameterfv)(GLuint texture, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetTextureLevelParameteriv)(GLuint texture, GLint level, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetTextureLevelParameterfv)(GLuint texture, GLint level, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetCompressedTextureImage)(GLuint texture, GLint level, GLsizei bufSize, void *pixels);
void (QOPENGLF_APIENTRYP GetTextureImage)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
void (QOPENGLF_APIENTRYP BindTextureUnit)(GLuint unit, GLuint texture);
void (QOPENGLF_APIENTRYP GenerateTextureMipmap)(GLuint texture);
void (QOPENGLF_APIENTRYP TextureParameteriv)(GLuint texture, GLenum pname, const GLint *param);
void (QOPENGLF_APIENTRYP TextureParameterIuiv)(GLuint texture, GLenum pname, const GLuint *params);
void (QOPENGLF_APIENTRYP TextureParameterIiv)(GLuint texture, GLenum pname, const GLint *params);
void (QOPENGLF_APIENTRYP TextureParameteri)(GLuint texture, GLenum pname, GLint param);
void (QOPENGLF_APIENTRYP TextureParameterfv)(GLuint texture, GLenum pname, const GLfloat *param);
void (QOPENGLF_APIENTRYP TextureParameterf)(GLuint texture, GLenum pname, GLfloat param);
void (QOPENGLF_APIENTRYP CopyTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP CopyTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP CopyTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP CompressedTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
void (QOPENGLF_APIENTRYP CompressedTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
void (QOPENGLF_APIENTRYP CompressedTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
void (QOPENGLF_APIENTRYP TextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
void (QOPENGLF_APIENTRYP TextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
void (QOPENGLF_APIENTRYP TextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
void (QOPENGLF_APIENTRYP TextureStorage3DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TextureStorage2DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
void (QOPENGLF_APIENTRYP TextureStorage3D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
void (QOPENGLF_APIENTRYP TextureStorage2D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP TextureStorage1D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
void (QOPENGLF_APIENTRYP TextureBufferRange)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size);
void (QOPENGLF_APIENTRYP TextureBuffer)(GLuint texture, GLenum internalformat, GLuint buffer);
void (QOPENGLF_APIENTRYP CreateTextures)(GLenum target, GLsizei n, GLuint *textures);
void (QOPENGLF_APIENTRYP GetNamedRenderbufferParameteriv)(GLuint renderbuffer, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP NamedRenderbufferStorageMultisample)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP NamedRenderbufferStorage)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP CreateRenderbuffers)(GLsizei n, GLuint *renderbuffers);
void (QOPENGLF_APIENTRYP GetNamedFramebufferAttachmentParameteriv)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetNamedFramebufferParameteriv)(GLuint framebuffer, GLenum pname, GLint *param);
GLenum (QOPENGLF_APIENTRYP CheckNamedFramebufferStatus)(GLuint framebuffer, GLenum target);
void (QOPENGLF_APIENTRYP BlitNamedFramebuffer)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
void (QOPENGLF_APIENTRYP ClearNamedFramebufferfi)(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil);
void (QOPENGLF_APIENTRYP ClearNamedFramebufferfv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value);
void (QOPENGLF_APIENTRYP ClearNamedFramebufferuiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value);
void (QOPENGLF_APIENTRYP ClearNamedFramebufferiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value);
void (QOPENGLF_APIENTRYP InvalidateNamedFramebufferSubData)(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP InvalidateNamedFramebufferData)(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments);
void (QOPENGLF_APIENTRYP NamedFramebufferReadBuffer)(GLuint framebuffer, GLenum src);
void (QOPENGLF_APIENTRYP NamedFramebufferDrawBuffers)(GLuint framebuffer, GLsizei n, const GLenum *bufs);
void (QOPENGLF_APIENTRYP NamedFramebufferDrawBuffer)(GLuint framebuffer, GLenum buf);
void (QOPENGLF_APIENTRYP NamedFramebufferTextureLayer)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
void (QOPENGLF_APIENTRYP NamedFramebufferTexture)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
void (QOPENGLF_APIENTRYP NamedFramebufferParameteri)(GLuint framebuffer, GLenum pname, GLint param);
void (QOPENGLF_APIENTRYP NamedFramebufferRenderbuffer)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
void (QOPENGLF_APIENTRYP CreateFramebuffers)(GLsizei n, GLuint *framebuffers);
void (QOPENGLF_APIENTRYP GetNamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizei size, void *data);
void (QOPENGLF_APIENTRYP GetNamedBufferPointerv)(GLuint buffer, GLenum pname, GLvoid* *params);
void (QOPENGLF_APIENTRYP GetNamedBufferParameteri64v)(GLuint buffer, GLenum pname, GLint64 *params);
void (QOPENGLF_APIENTRYP GetNamedBufferParameteriv)(GLuint buffer, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP FlushMappedNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizei length);
GLboolean (QOPENGLF_APIENTRYP UnmapNamedBuffer)(GLuint buffer);
GLvoid* (QOPENGLF_APIENTRYP MapNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access);
GLvoid* (QOPENGLF_APIENTRYP MapNamedBuffer)(GLuint buffer, GLenum access);
void (QOPENGLF_APIENTRYP ClearNamedBufferSubData)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data);
void (QOPENGLF_APIENTRYP ClearNamedBufferData)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
void (QOPENGLF_APIENTRYP CopyNamedBufferSubData)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size);
void (QOPENGLF_APIENTRYP NamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizei size, const void *data);
void (QOPENGLF_APIENTRYP NamedBufferData)(GLuint buffer, GLsizei size, const void *data, GLenum usage);
void (QOPENGLF_APIENTRYP NamedBufferStorage)(GLuint buffer, GLsizei size, const void *data, GLbitfield flags);
void (QOPENGLF_APIENTRYP CreateBuffers)(GLsizei n, GLuint *buffers);
void (QOPENGLF_APIENTRYP GetTransformFeedbacki64_v)(GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
void (QOPENGLF_APIENTRYP GetTransformFeedbacki_v)(GLuint xfb, GLenum pname, GLuint index, GLint *param);
void (QOPENGLF_APIENTRYP GetTransformFeedbackiv)(GLuint xfb, GLenum pname, GLint *param);
void (QOPENGLF_APIENTRYP TransformFeedbackBufferRange)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size);
void (QOPENGLF_APIENTRYP TransformFeedbackBufferBase)(GLuint xfb, GLuint index, GLuint buffer);
void (QOPENGLF_APIENTRYP CreateTransformFeedbacks)(GLsizei n, GLuint *ids);
void (QOPENGLF_APIENTRYP ClipControl)(GLenum origin, GLenum depth);
};
class QOpenGLFunctions_1_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
{
public:
@ -872,9 +1046,9 @@ public:
void (QOPENGLF_APIENTRYP GetClipPlane)(GLenum plane, GLdouble *equation);
void (QOPENGLF_APIENTRYP DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
void (QOPENGLF_APIENTRYP CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
void (QOPENGLF_APIENTRYP PixelMapusv)(GLenum map, GLint mapsize, const GLushort *values);
void (QOPENGLF_APIENTRYP PixelMapuiv)(GLenum map, GLint mapsize, const GLuint *values);
void (QOPENGLF_APIENTRYP PixelMapfv)(GLenum map, GLint mapsize, const GLfloat *values);
void (QOPENGLF_APIENTRYP PixelMapusv)(GLenum map, GLsizei mapsize, const GLushort *values);
void (QOPENGLF_APIENTRYP PixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint *values);
void (QOPENGLF_APIENTRYP PixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat *values);
void (QOPENGLF_APIENTRYP PixelTransferi)(GLenum pname, GLint param);
void (QOPENGLF_APIENTRYP PixelTransferf)(GLenum pname, GLfloat param);
void (QOPENGLF_APIENTRYP PixelZoom)(GLfloat xfactor, GLfloat yfactor);
@ -1107,12 +1281,15 @@ public:
// OpenGL 1.1 deprecated functions
void (QOPENGLF_APIENTRYP PushClientAttrib)(GLbitfield mask);
void (QOPENGLF_APIENTRYP PopClientAttrib)();
void (QOPENGLF_APIENTRYP Indexubv)(const GLubyte *c);
void (QOPENGLF_APIENTRYP Indexub)(GLubyte c);
void (QOPENGLF_APIENTRYP PrioritizeTextures)(GLsizei n, const GLuint *textures, const GLfloat *priorities);
GLboolean (QOPENGLF_APIENTRYP AreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences);
void (QOPENGLF_APIENTRYP VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void (QOPENGLF_APIENTRYP TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
void (QOPENGLF_APIENTRYP NormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
void (QOPENGLF_APIENTRYP InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer);
void (QOPENGLF_APIENTRYP GetPointerv)(GLenum pname, GLvoid* *params);
void (QOPENGLF_APIENTRYP IndexPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
void (QOPENGLF_APIENTRYP EnableClientState)(GLenum array);
void (QOPENGLF_APIENTRYP EdgeFlagPointer)(GLsizei stride, const GLvoid *pointer);
@ -1130,38 +1307,38 @@ public:
static QOpenGLVersionStatus versionStatus();
// OpenGL 1.2 deprecated functions
void (QOPENGLF_APIENTRYP ResetMinmax)(GLenum target);
void (QOPENGLF_APIENTRYP ResetHistogram)(GLenum target);
void (QOPENGLF_APIENTRYP Minmax)(GLenum target, GLenum internalformat, GLboolean sink);
void (QOPENGLF_APIENTRYP Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
void (QOPENGLF_APIENTRYP GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
void (QOPENGLF_APIENTRYP GetHistogramParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
void (QOPENGLF_APIENTRYP SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
void (QOPENGLF_APIENTRYP GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
void (QOPENGLF_APIENTRYP GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid *image);
void (QOPENGLF_APIENTRYP CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint *params);
void (QOPENGLF_APIENTRYP ConvolutionParameteri)(GLenum target, GLenum pname, GLint params);
void (QOPENGLF_APIENTRYP ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
void (QOPENGLF_APIENTRYP ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params);
void (QOPENGLF_APIENTRYP ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
void (QOPENGLF_APIENTRYP ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
void (QOPENGLF_APIENTRYP CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
void (QOPENGLF_APIENTRYP GetColorTableParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid *table);
void (QOPENGLF_APIENTRYP CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP ColorTableParameteriv)(GLenum target, GLenum pname, const GLint *params);
void (QOPENGLF_APIENTRYP ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
void (QOPENGLF_APIENTRYP ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
void (QOPENGLF_APIENTRYP ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
void (QOPENGLF_APIENTRYP ColorTableParameteriv)(GLenum target, GLenum pname, const GLint *params);
void (QOPENGLF_APIENTRYP CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid *table);
void (QOPENGLF_APIENTRYP GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetColorTableParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
void (QOPENGLF_APIENTRYP CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
void (QOPENGLF_APIENTRYP ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
void (QOPENGLF_APIENTRYP ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params);
void (QOPENGLF_APIENTRYP ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
void (QOPENGLF_APIENTRYP ConvolutionParameteri)(GLenum target, GLenum pname, GLint params);
void (QOPENGLF_APIENTRYP ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint *params);
void (QOPENGLF_APIENTRYP CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
void (QOPENGLF_APIENTRYP CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
void (QOPENGLF_APIENTRYP GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid *image);
void (QOPENGLF_APIENTRYP GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
void (QOPENGLF_APIENTRYP SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
void (QOPENGLF_APIENTRYP GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
void (QOPENGLF_APIENTRYP GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetHistogramParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
void (QOPENGLF_APIENTRYP GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat *params);
void (QOPENGLF_APIENTRYP GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint *params);
void (QOPENGLF_APIENTRYP Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
void (QOPENGLF_APIENTRYP Minmax)(GLenum target, GLenum internalformat, GLboolean sink);
void (QOPENGLF_APIENTRYP ResetHistogram)(GLenum target);
void (QOPENGLF_APIENTRYP ResetMinmax)(GLenum target);
};
@ -1262,85 +1439,70 @@ public:
};
class QOpenGLFunctions_2_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
class QOpenGLFunctions_3_3_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
{
public:
QOpenGLFunctions_2_0_DeprecatedBackend(QOpenGLContext *context);
QOpenGLFunctions_3_3_DeprecatedBackend(QOpenGLContext *context);
static QOpenGLVersionStatus versionStatus();
// OpenGL 2.0 deprecated functions
void (QOPENGLF_APIENTRYP VertexAttrib4usv)(GLuint index, const GLushort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4ubv)(GLuint index, const GLubyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib4sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
void (QOPENGLF_APIENTRYP VertexAttrib4iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void (QOPENGLF_APIENTRYP VertexAttrib4dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
void (QOPENGLF_APIENTRYP VertexAttrib4bv)(GLuint index, const GLbyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nusv)(GLuint index, const GLushort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nuiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nubv)(GLuint index, const GLubyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
void (QOPENGLF_APIENTRYP VertexAttrib4Nsv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Niv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttrib4Nbv)(GLuint index, const GLbyte *v);
void (QOPENGLF_APIENTRYP VertexAttrib3sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z);
void (QOPENGLF_APIENTRYP VertexAttrib3fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
void (QOPENGLF_APIENTRYP VertexAttrib3dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
void (QOPENGLF_APIENTRYP VertexAttrib2sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib2s)(GLuint index, GLshort x, GLshort y);
void (QOPENGLF_APIENTRYP VertexAttrib2fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib2f)(GLuint index, GLfloat x, GLfloat y);
void (QOPENGLF_APIENTRYP VertexAttrib2dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y);
void (QOPENGLF_APIENTRYP VertexAttrib1sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttrib1s)(GLuint index, GLshort x);
void (QOPENGLF_APIENTRYP VertexAttrib1fv)(GLuint index, const GLfloat *v);
void (QOPENGLF_APIENTRYP VertexAttrib1f)(GLuint index, GLfloat x);
void (QOPENGLF_APIENTRYP VertexAttrib1dv)(GLuint index, const GLdouble *v);
void (QOPENGLF_APIENTRYP VertexAttrib1d)(GLuint index, GLdouble x);
// OpenGL 3.3 deprecated functions
void (QOPENGLF_APIENTRYP SecondaryColorP3uiv)(GLenum type, const GLuint *color);
void (QOPENGLF_APIENTRYP SecondaryColorP3ui)(GLenum type, GLuint color);
void (QOPENGLF_APIENTRYP ColorP4uiv)(GLenum type, const GLuint *color);
void (QOPENGLF_APIENTRYP ColorP4ui)(GLenum type, GLuint color);
void (QOPENGLF_APIENTRYP ColorP3uiv)(GLenum type, const GLuint *color);
void (QOPENGLF_APIENTRYP ColorP3ui)(GLenum type, GLuint color);
void (QOPENGLF_APIENTRYP NormalP3uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP NormalP3ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP4uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP4ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP3uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP3ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP2uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP2ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP1uiv)(GLenum texture, GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP MultiTexCoordP1ui)(GLenum texture, GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP4uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP4ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP3uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP3ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP2uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP2ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP TexCoordP1uiv)(GLenum type, const GLuint *coords);
void (QOPENGLF_APIENTRYP TexCoordP1ui)(GLenum type, GLuint coords);
void (QOPENGLF_APIENTRYP VertexP4uiv)(GLenum type, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexP4ui)(GLenum type, GLuint value);
void (QOPENGLF_APIENTRYP VertexP3uiv)(GLenum type, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexP3ui)(GLenum type, GLuint value);
void (QOPENGLF_APIENTRYP VertexP2uiv)(GLenum type, const GLuint *value);
void (QOPENGLF_APIENTRYP VertexP2ui)(GLenum type, GLuint value);
};
class QOpenGLFunctions_3_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
class QOpenGLFunctions_4_5_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
{
public:
QOpenGLFunctions_3_0_DeprecatedBackend(QOpenGLContext *context);
QOpenGLFunctions_4_5_DeprecatedBackend(QOpenGLContext *context);
static QOpenGLVersionStatus versionStatus();
// OpenGL 3.0 deprecated functions
void (QOPENGLF_APIENTRYP VertexAttribI4usv)(GLuint index, const GLushort *v);
void (QOPENGLF_APIENTRYP VertexAttribI4ubv)(GLuint index, const GLubyte *v);
void (QOPENGLF_APIENTRYP VertexAttribI4sv)(GLuint index, const GLshort *v);
void (QOPENGLF_APIENTRYP VertexAttribI4bv)(GLuint index, const GLbyte *v);
void (QOPENGLF_APIENTRYP VertexAttribI4uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI3uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI2uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI1uiv)(GLuint index, const GLuint *v);
void (QOPENGLF_APIENTRYP VertexAttribI4iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI3iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI2iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI1iv)(GLuint index, const GLint *v);
void (QOPENGLF_APIENTRYP VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
void (QOPENGLF_APIENTRYP VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
void (QOPENGLF_APIENTRYP VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
void (QOPENGLF_APIENTRYP VertexAttribI1ui)(GLuint index, GLuint x);
void (QOPENGLF_APIENTRYP VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
void (QOPENGLF_APIENTRYP VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
void (QOPENGLF_APIENTRYP VertexAttribI2i)(GLuint index, GLint x, GLint y);
void (QOPENGLF_APIENTRYP VertexAttribI1i)(GLuint index, GLint x);
// OpenGL 4.5 deprecated functions
void (QOPENGLF_APIENTRYP GetnMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
void (QOPENGLF_APIENTRYP GetnHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
void (QOPENGLF_APIENTRYP GetnSeparableFilter)(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid *row, GLsizei columnBufSize, GLvoid *column, GLvoid *span);
void (QOPENGLF_APIENTRYP GetnConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *image);
void (QOPENGLF_APIENTRYP GetnColorTable)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *table);
void (QOPENGLF_APIENTRYP GetnPolygonStipple)(GLsizei bufSize, GLubyte *pattern);
void (QOPENGLF_APIENTRYP GetnPixelMapusv)(GLenum map, GLsizei bufSize, GLushort *values);
void (QOPENGLF_APIENTRYP GetnPixelMapuiv)(GLenum map, GLsizei bufSize, GLuint *values);
void (QOPENGLF_APIENTRYP GetnPixelMapfv)(GLenum map, GLsizei bufSize, GLfloat *values);
void (QOPENGLF_APIENTRYP GetnMapiv)(GLenum target, GLenum query, GLsizei bufSize, GLint *v);
void (QOPENGLF_APIENTRYP GetnMapfv)(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
void (QOPENGLF_APIENTRYP GetnMapdv)(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
};
#else
// No need for backend classes with function pointers with ES2.

16
src/gui/opengl/qopenglversionfunctionsfactory.cpp
View File

@ -43,6 +43,10 @@
#include "qopenglversionfunctionsfactory_p.h"
#if !defined(QT_OPENGL_ES_2)
#include "qopenglfunctions_4_5_core.h"
#include "qopenglfunctions_4_5_compatibility.h"
#include "qopenglfunctions_4_4_core.h"
#include "qopenglfunctions_4_4_compatibility.h"
#include "qopenglfunctions_4_3_core.h"
#include "qopenglfunctions_4_3_compatibility.h"
#include "qopenglfunctions_4_2_core.h"
@ -80,7 +84,11 @@ QAbstractOpenGLFunctions *QOpenGLVersionFunctionsFactory::create(const QOpenGLVe
if (versionProfile.hasProfiles()) {
switch (versionProfile.profile()) {
case QSurfaceFormat::CoreProfile:
if (major == 4 && minor == 3)
if (major == 4 && minor == 5)
return new QOpenGLFunctions_4_5_Core;
else if (major == 4 && minor == 4)
return new QOpenGLFunctions_4_4_Core;
else if (major == 4 && minor == 3)
return new QOpenGLFunctions_4_3_Core;
else if (major == 4 && minor == 2)
return new QOpenGLFunctions_4_2_Core;
@ -95,7 +103,11 @@ QAbstractOpenGLFunctions *QOpenGLVersionFunctionsFactory::create(const QOpenGLVe
break;
case QSurfaceFormat::CompatibilityProfile:
if (major == 4 && minor == 3)
if (major == 4 && minor == 5)
return new QOpenGLFunctions_4_5_Compatibility;
else if (major == 4 && minor == 4)
return new QOpenGLFunctions_4_4_Compatibility;
else if (major == 4 && minor == 3)
return new QOpenGLFunctions_4_3_Compatibility;
else if (major == 4 && minor == 2)
return new QOpenGLFunctions_4_2_Compatibility;