QOpenGLTextureHelper: fix the DSA emulation

The DSA emulator functions query which texture is currently bound
to a given target, then bind the new one, perform an operation,
and bind the old one back.

The problem is that in order to query what's currently bound to the
GL_TEXTURE_<X> target one needs to call glGetIntegerv passing
GL_BINDING_TEXTURE_<X>. Since both GL_TEXTURE_X and GL_BINDING_TEXTURE_X
values are completely arbitrary (not contiguous nor related in any way)
we need to pass *both* them to the functions.

The right GL_BINDING_TEXTURE_X was getting already chosen (and stored)
at texture creation time by QOpenGLTexture, so it's just a matter
of passing it around.

For the "real" DSA functions, the binding target is ignored.

Change-Id: Ida823abbfb142d4a22bf9f9a762b160b7e281c6d
Reviewed-by: James Turner <james.turner@kdab.com>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

2 files changed, 241 insertions, 217 deletions

diff --git a/src/gui/opengl/qopengltexture.cpp b/src/gui/opengl/qopengltexture.cpp
index 76543d1e9f..6a328436f6 100644
--- a/src/gui/opengl/qopengltexture.cpp
+++ b/src/gui/opengl/qopengltexture.cpp
@@ -320,7 +320,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
 
     case QOpenGLTexture::Target1D:
         for (int level = 0; level < mipLevels; ++level)
-            texFuncs->glTextureImage1D(textureId, target, level, format,
+            texFuncs->glTextureImage1D(textureId, target, bindingTarget, level, format,
                                        mipLevelSize(level, dimensions[0]),
                                        0,
                                        QOpenGLTexture::RGBA, QOpenGLTexture::UInt8, 0);
@@ -329,7 +329,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
     case QOpenGLTexture::Target1DArray:
         if (features.testFlag(QOpenGLTexture::TextureArrays)) {
             for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage2D(textureId, target, level, format,
+                texFuncs->glTextureImage2D(textureId, target, bindingTarget, level, format,
                                            mipLevelSize(level, dimensions[0]),
                                            layers,
                                            0,
@@ -344,7 +344,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
     case QOpenGLTexture::TargetCubeMap:
     case QOpenGLTexture::TargetRectangle:
         for (int level = 0; level < mipLevels; ++level)
-            texFuncs->glTextureImage2D(textureId, target, level, format,
+            texFuncs->glTextureImage2D(textureId, target, bindingTarget, level, format,
                                        mipLevelSize(level, dimensions[0]),
                                        mipLevelSize(level, dimensions[1]),
                                        0,
@@ -354,7 +354,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
     case QOpenGLTexture::Target2DArray:
         if (features.testFlag(QOpenGLTexture::TextureArrays)) {
             for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage3D(textureId, target, level, format,
+                texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
                                            mipLevelSize(level, dimensions[0]),
                                            mipLevelSize(level, dimensions[1]),
                                            layers,
@@ -370,7 +370,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
         // Cubemap arrays must specify number of layer-faces (6 * layers) as depth parameter
         if (features.testFlag(QOpenGLTexture::TextureCubeMapArrays)) {
             for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage3D(textureId, target, level, format,
+                texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
                                            mipLevelSize(level, dimensions[0]),
                                            mipLevelSize(level, dimensions[1]),
                                            6 * layers,
@@ -385,7 +385,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
     case QOpenGLTexture::Target3D:
         if (features.testFlag(QOpenGLTexture::Texture3D)) {
             for (int level = 0; level < mipLevels; ++level)
-                texFuncs->glTextureImage3D(textureId, target, level, format,
+                texFuncs->glTextureImage3D(textureId, target, bindingTarget, level, format,
                                            mipLevelSize(level, dimensions[0]),
                                            mipLevelSize(level, dimensions[1]),
                                            mipLevelSize(level, dimensions[2]),
@@ -399,7 +399,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
 
     case QOpenGLTexture::Target2DMultisample:
         if (features.testFlag(QOpenGLTexture::TextureMultisample)) {
-            texFuncs->glTextureImage2DMultisample(textureId, target, samples, format,
+            texFuncs->glTextureImage2DMultisample(textureId, target, bindingTarget, samples, format,
                                                   dimensions[0], dimensions[1],
                                                   fixedSamplePositions);
         } else {
@@ -411,7 +411,7 @@ void QOpenGLTexturePrivate::allocateMutableStorage()
     case QOpenGLTexture::Target2DMultisampleArray:
         if (features.testFlag(QOpenGLTexture::TextureMultisample)
                 && features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureImage3DMultisample(textureId, target, samples, format,
+            texFuncs->glTextureImage3DMultisample(textureId, target, bindingTarget, samples, format,
                                                   dimensions[0], dimensions[1], layers,
                                                   fixedSamplePositions);
         } else {
@@ -433,13 +433,13 @@ void QOpenGLTexturePrivate::allocateImmutableStorage()
         return;
 
     case QOpenGLTexture::Target1D:
-        texFuncs->glTextureStorage1D(textureId, target, mipLevels, format,
+        texFuncs->glTextureStorage1D(textureId, target, bindingTarget, mipLevels, format,
                                      dimensions[0]);
         break;
 
     case QOpenGLTexture::Target1DArray:
         if (features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureStorage2D(textureId, target, mipLevels, format,
+            texFuncs->glTextureStorage2D(textureId, target, bindingTarget, mipLevels, format,
                                          dimensions[0], layers);
         } else {
             qWarning("Array textures are not supported");
@@ -450,13 +450,13 @@ void QOpenGLTexturePrivate::allocateImmutableStorage()
     case QOpenGLTexture::Target2D:
     case QOpenGLTexture::TargetCubeMap:
     case QOpenGLTexture::TargetRectangle:
-        texFuncs->glTextureStorage2D(textureId, target, mipLevels, format,
+        texFuncs->glTextureStorage2D(textureId, target, bindingTarget, mipLevels, format,
                                      dimensions[0], dimensions[1]);
         break;
 
     case QOpenGLTexture::Target2DArray:
         if (features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureStorage3D(textureId, target, mipLevels, format,
+            texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
                                          dimensions[0], dimensions[1], layers);
         } else {
             qWarning("Array textures are not supported");
@@ -467,7 +467,7 @@ void QOpenGLTexturePrivate::allocateImmutableStorage()
     case QOpenGLTexture::TargetCubeMapArray:
         // Cubemap arrays must specify number of layer-faces (6 * layers) as depth parameter
         if (features.testFlag(QOpenGLTexture::TextureCubeMapArrays)) {
-            texFuncs->glTextureStorage3D(textureId, target, mipLevels, format,
+            texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
                                          dimensions[0], dimensions[1], 6 * layers);
         } else {
             qWarning("Cubemap Array textures are not supported");
@@ -477,7 +477,7 @@ void QOpenGLTexturePrivate::allocateImmutableStorage()
 
     case QOpenGLTexture::Target3D:
         if (features.testFlag(QOpenGLTexture::Texture3D)) {
-            texFuncs->glTextureStorage3D(textureId, target, mipLevels, format,
+            texFuncs->glTextureStorage3D(textureId, target, bindingTarget, mipLevels, format,
                                          dimensions[0], dimensions[1], dimensions[2]);
         } else {
             qWarning("3D textures are not supported");
@@ -487,7 +487,7 @@ void QOpenGLTexturePrivate::allocateImmutableStorage()
 
     case QOpenGLTexture::Target2DMultisample:
         if (features.testFlag(QOpenGLTexture::TextureMultisample)) {
-            texFuncs->glTextureStorage2DMultisample(textureId, target, samples, format,
+            texFuncs->glTextureStorage2DMultisample(textureId, target, bindingTarget, samples, format,
                                                     dimensions[0], dimensions[1],
                                                     fixedSamplePositions);
         } else {
@@ -499,7 +499,7 @@ void QOpenGLTexturePrivate::allocateImmutableStorage()
     case QOpenGLTexture::Target2DMultisampleArray:
         if (features.testFlag(QOpenGLTexture::TextureMultisample)
                 && features.testFlag(QOpenGLTexture::TextureArrays)) {
-            texFuncs->glTextureStorage3DMultisample(textureId, target, samples, format,
+            texFuncs->glTextureStorage3DMultisample(textureId, target, bindingTarget, samples, format,
                                                     dimensions[0], dimensions[1], layers,
                                                     fixedSamplePositions);
         } else {
@@ -520,14 +520,14 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
     case QOpenGLTexture::Target1D:
         Q_UNUSED(layer);
         Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage1D(textureId, target, mipLevel,
+        texFuncs->glTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
                                       0, mipLevelSize( mipLevel, dimensions[0] ),
                                       sourceFormat, sourceType, data, options);
         break;
 
     case QOpenGLTexture::Target1DArray:
         Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage2D(textureId, target, mipLevel,
+        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
                                       0, layer,
                                       mipLevelSize(mipLevel, dimensions[0]),
                                       1,
@@ -536,7 +536,7 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
     case QOpenGLTexture::Target2D:
         Q_UNUSED(layer);
         Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage2D(textureId, target, mipLevel,
+        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
                                       0, 0,
                                       mipLevelSize(mipLevel, dimensions[0]),
                                       mipLevelSize(mipLevel, dimensions[1]),
@@ -545,7 +545,7 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
 
     case QOpenGLTexture::Target2DArray:
         Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage3D(textureId, target, mipLevel,
+        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
                                       0, 0, layer,
                                       mipLevelSize(mipLevel, dimensions[0]),
                                       mipLevelSize(mipLevel, dimensions[1]),
@@ -555,7 +555,7 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
 
     case QOpenGLTexture::Target3D:
         Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage3D(textureId, target, mipLevel,
+        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
                                       0, 0, layer,
                                       mipLevelSize(mipLevel, dimensions[0]),
                                       mipLevelSize(mipLevel, dimensions[1]),
@@ -565,7 +565,7 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
 
     case QOpenGLTexture::TargetCubeMap:
         Q_UNUSED(layer);
-        texFuncs->glTextureSubImage2D(textureId, cubeFace, mipLevel,
+        texFuncs->glTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
                                       0, 0,
                                       mipLevelSize(mipLevel, dimensions[0]),
                                       mipLevelSize(mipLevel, dimensions[1]),
@@ -575,7 +575,7 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
     case QOpenGLTexture::TargetCubeMapArray: {
         int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
         int layerFace = 6 * layer + faceIndex;
-        texFuncs->glTextureSubImage3D(textureId, target, mipLevel,
+        texFuncs->glTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
                                       0, 0, layerFace,
                                       mipLevelSize(mipLevel, dimensions[0]),
                                       mipLevelSize(mipLevel, dimensions[1]),
@@ -588,7 +588,7 @@ void QOpenGLTexturePrivate::setData(int mipLevel, int layer, QOpenGLTexture::Cub
         Q_UNUSED(mipLevel);
         Q_UNUSED(layer);
         Q_UNUSED(cubeFace);
-        texFuncs->glTextureSubImage2D(textureId, target, 0,
+        texFuncs->glTextureSubImage2D(textureId, target, bindingTarget, 0,
                                       0, 0,
                                       dimensions[0],
                                       dimensions[1],
@@ -618,14 +618,14 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
     case QOpenGLTexture::Target1D:
         Q_UNUSED(layer);
         Q_UNUSED(cubeFace);
-        texFuncs->glCompressedTextureSubImage1D(textureId, target, mipLevel,
+        texFuncs->glCompressedTextureSubImage1D(textureId, target, bindingTarget, mipLevel,
                                                 0, mipLevelSize( mipLevel, dimensions[0] ),
                                                 format, dataSize, data, options);
         break;
 
     case QOpenGLTexture::Target1DArray:
         Q_UNUSED(cubeFace);
-        texFuncs->glCompressedTextureSubImage2D(textureId, target, mipLevel,
+        texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
                                                 0, layer,
                                                 mipLevelSize(mipLevel, dimensions[0]),
                                                 1,
@@ -634,7 +634,7 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
     case QOpenGLTexture::Target2D:
         Q_UNUSED(layer);
         Q_UNUSED(cubeFace);
-        texFuncs->glCompressedTextureSubImage2D(textureId, target, mipLevel,
+        texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, mipLevel,
                                                 0, 0,
                                                 mipLevelSize(mipLevel, dimensions[0]),
                                                 mipLevelSize(mipLevel, dimensions[1]),
@@ -643,7 +643,7 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
 
     case QOpenGLTexture::Target2DArray:
         Q_UNUSED(cubeFace);
-        texFuncs->glCompressedTextureSubImage3D(textureId, target, mipLevel,
+        texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
                                                 0, 0, layer,
                                                 mipLevelSize(mipLevel, dimensions[0]),
                                                 mipLevelSize(mipLevel, dimensions[1]),
@@ -653,7 +653,7 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
 
     case QOpenGLTexture::Target3D:
         Q_UNUSED(cubeFace);
-        texFuncs->glCompressedTextureSubImage3D(textureId, target, mipLevel,
+        texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
                                                 0, 0, layer,
                                                 mipLevelSize(mipLevel, dimensions[0]),
                                                 mipLevelSize(mipLevel, dimensions[1]),
@@ -663,7 +663,7 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
 
     case QOpenGLTexture::TargetCubeMap:
         Q_UNUSED(layer);
-        texFuncs->glCompressedTextureSubImage2D(textureId, cubeFace, mipLevel,
+        texFuncs->glCompressedTextureSubImage2D(textureId, cubeFace, bindingTarget, mipLevel,
                                                 0, 0,
                                                 mipLevelSize(mipLevel, dimensions[0]),
                                                 mipLevelSize(mipLevel, dimensions[1]),
@@ -673,7 +673,7 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
     case QOpenGLTexture::TargetCubeMapArray: {
         int faceIndex = cubeFace - QOpenGLTexture::CubeMapPositiveX;
         int layerFace = 6 * layer + faceIndex;
-        texFuncs->glCompressedTextureSubImage3D(textureId, target, mipLevel,
+        texFuncs->glCompressedTextureSubImage3D(textureId, target, bindingTarget, mipLevel,
                                                 0, 0, layerFace,
                                                 mipLevelSize(mipLevel, dimensions[0]),
                                                 mipLevelSize(mipLevel, dimensions[1]),
@@ -686,7 +686,7 @@ void QOpenGLTexturePrivate::setCompressedData(int mipLevel, int layer, QOpenGLTe
         Q_UNUSED(mipLevel);
         Q_UNUSED(layer);
         Q_UNUSED(cubeFace);
-        texFuncs->glCompressedTextureSubImage2D(textureId, target, 0,
+        texFuncs->glCompressedTextureSubImage2D(textureId, target, bindingTarget, 0,
                                                 0, 0,
                                                 dimensions[0],
                                                 dimensions[1],
@@ -715,7 +715,7 @@ void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::WrapMode mode)
     case QOpenGLTexture::Target1DArray:
     case QOpenGLTexture::TargetBuffer:
         wrapModes[0] = mode;
-        texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_S, mode);
+        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
         break;
 
     case QOpenGLTexture::Target2D:
@@ -726,15 +726,15 @@ void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::WrapMode mode)
     case QOpenGLTexture::Target2DMultisampleArray:
     case QOpenGLTexture::TargetRectangle:
         wrapModes[0] = wrapModes[1] = mode;
-        texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_S, mode);
-        texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_T, mode);
+        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
+        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
         break;
 
     case QOpenGLTexture::Target3D:
         wrapModes[0] = wrapModes[1] = wrapModes[2] = mode;
-        texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_S, mode);
-        texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_T, mode);
-        texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_R, mode);
+        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
+        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
+        texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_R, mode);
         break;
     }
 }
@@ -748,7 +748,7 @@ void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::CoordinateDirection dire
         switch (direction) {
         case QOpenGLTexture::DirectionS:
             wrapModes[0] = mode;
-            texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_S, mode);
+            texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
             break;
 
         case QOpenGLTexture::DirectionT:
@@ -768,12 +768,12 @@ void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::CoordinateDirection dire
         switch (direction) {
         case QOpenGLTexture::DirectionS:
             wrapModes[0] = mode;
-            texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_S, mode);
+            texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_S, mode);
             break;
 
         case QOpenGLTexture::DirectionT:
             wrapModes[1] = mode;
-            texFuncs->glTextureParameteri(textureId, target, GL_TEXTURE_WRAP_T, mode);
+            texFuncs->glTextureParameteri(textureId, target, bindingTarget, GL_TEXTURE_WRAP_T, mode);
             break;
 
         case QOpenGLTexture::DirectionR:
@@ -786,17 +786,17 @@ void QOpenGLTexturePrivate::setWrapMode(QOpenGLTexture::CoordinateDirection dire
         switch (direction) {
         case QOpenGLTexture::DirectionS:
             wrapModes[0] = mode;
-            texFuncs->glTextureParameteri(textureId, target, direction, mode);
+            texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
             break;
 
         case QOpenGLTexture::DirectionT:
             wrapModes[1] = mode;
-            texFuncs->glTextureParameteri(textureId, target, direction, mode);
+            texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
             break;
 
         case QOpenGLTexture::DirectionR:
             wrapModes[2] = mode;
-            texFuncs->glTextureParameteri(textureId, target, direction, mode);
+            texFuncs->glTextureParameteri(textureId, target, bindingTarget, direction, mode);
             break;
         }
         break;
@@ -2469,7 +2469,7 @@ void QOpenGLTexture::setMipBaseLevel(int baseLevel)
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(baseLevel <= d->maxLevel);
     d->baseLevel = baseLevel;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_BASE_LEVEL, baseLevel);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BASE_LEVEL, baseLevel);
 #else
     Q_UNUSED(baseLevel);
     qWarning("QOpenGLTexture: Mipmap base level is not supported");
@@ -2503,7 +2503,7 @@ void QOpenGLTexture::setMipMaxLevel(int maxLevel)
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(d->baseLevel <= maxLevel);
     d->maxLevel = maxLevel;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MAX_LEVEL, maxLevel);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LEVEL, maxLevel);
 #else
     Q_UNUSED(maxLevel);
     qWarning("QOpenGLTexture: Mipmap max level is not supported");
@@ -2536,8 +2536,8 @@ void QOpenGLTexture::setMipLevelRange(int baseLevel, int maxLevel)
     Q_ASSERT(d->textureId);
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(baseLevel <= maxLevel);
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_BASE_LEVEL, baseLevel);
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MAX_LEVEL, maxLevel);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BASE_LEVEL, baseLevel);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LEVEL, maxLevel);
 #else
     Q_UNUSED(baseLevel);
     Q_UNUSED(maxLevel);
@@ -2594,7 +2594,7 @@ void QOpenGLTexture::generateMipMaps()
     Q_D(QOpenGLTexture);
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(d->textureId);
-    d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target);
+    d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target, d->bindingTarget);
 }
 
 /*!
@@ -2618,7 +2618,7 @@ void QOpenGLTexture::generateMipMaps(int baseLevel, bool resetBaseLevel)
     if (resetBaseLevel)
         oldBaseLevel = mipBaseLevel();
     setMipBaseLevel(baseLevel);
-    d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target);
+    d->texFuncs->glGenerateTextureMipmap(d->textureId, d->target, d->bindingTarget);
     if (resetBaseLevel)
         setMipBaseLevel(oldBaseLevel);
 }
@@ -2647,7 +2647,7 @@ void QOpenGLTexture::setSwizzleMask(SwizzleComponent component, SwizzleValue val
         return;
     }
     d->swizzleMask[component - SwizzleRed] = value;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, component, value);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, component, value);
 #else
     Q_UNUSED(component);
     Q_UNUSED(value);
@@ -2675,7 +2675,7 @@ void QOpenGLTexture::setSwizzleMask(SwizzleValue r, SwizzleValue g,
     d->swizzleMask[1] = g;
     d->swizzleMask[2] = b;
     d->swizzleMask[3] = a;
-    d->texFuncs->glTextureParameteriv(d->textureId, d->target, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
+    d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
 #else
     Q_UNUSED(r);
     Q_UNUSED(g);
@@ -2717,7 +2717,7 @@ void QOpenGLTexture::setDepthStencilMode(QOpenGLTexture::DepthStencilMode mode)
         return;
     }
     d->depthStencilMode = mode;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_DEPTH_STENCIL_TEXTURE_MODE, mode);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_DEPTH_STENCIL_TEXTURE_MODE, mode);
 #else
     Q_UNUSED(mode);
     qWarning("QOpenGLTexture: DepthStencil Mode is not supported");
@@ -2747,7 +2747,7 @@ void QOpenGLTexture::setMinificationFilter(QOpenGLTexture::Filter filter)
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(d->textureId);
     d->minFilter = filter;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MIN_FILTER, filter);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_FILTER, filter);
 }
 
 /*!
@@ -2773,7 +2773,7 @@ void QOpenGLTexture::setMagnificationFilter(QOpenGLTexture::Filter filter)
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(d->textureId);
     d->magFilter = filter;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MAG_FILTER, filter);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAG_FILTER, filter);
 }
 
 /*!
@@ -2802,8 +2802,8 @@ void QOpenGLTexture::setMinMagFilters(QOpenGLTexture::Filter minificationFilter,
     Q_ASSERT(d->textureId);
     d->minFilter = minificationFilter;
     d->magFilter = magnificationFilter;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MIN_FILTER, minificationFilter);
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MAG_FILTER, magnificationFilter);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_FILTER, minificationFilter);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAG_FILTER, magnificationFilter);
 }
 
 /*!
@@ -2834,7 +2834,7 @@ void QOpenGLTexture::setMaximumAnisotropy(float anisotropy)
         return;
     }
     d->maxAnisotropy = anisotropy;
-    d->texFuncs->glTextureParameteri(d->textureId, d->target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
+    d->texFuncs->glTextureParameteri(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
 }
 
 /*!
@@ -2907,7 +2907,7 @@ void QOpenGLTexture::setBorderColor(QColor color)
     d->borderColor.clear();
     for (int i = 0; i < 4; ++i)
         d->borderColor.append(QVariant(values[i]));
-    d->texFuncs->glTextureParameterfv(d->textureId, d->target, GL_TEXTURE_BORDER_COLOR, values);
+    d->texFuncs->glTextureParameterfv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
 #else
     Q_UNUSED(color);
     qWarning("QOpenGLTexture: Border color is not supported");
@@ -2932,7 +2932,7 @@ void QOpenGLTexture::setBorderColor(float r, float g, float b, float a)
     d->borderColor.clear();
     for (int i = 0; i < 4; ++i)
         d->borderColor.append(QVariant(values[i]));
-    d->texFuncs->glTextureParameterfv(d->textureId, d->target, GL_TEXTURE_BORDER_COLOR, values);
+    d->texFuncs->glTextureParameterfv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
 #else
     Q_UNUSED(r);
     Q_UNUSED(g);
@@ -2960,7 +2960,7 @@ void QOpenGLTexture::setBorderColor(int r, int g, int b, int a)
     d->borderColor.clear();
     for (int i = 0; i < 4; ++i)
         d->borderColor.append(QVariant(values[i]));
-    d->texFuncs->glTextureParameteriv(d->textureId, d->target, GL_TEXTURE_BORDER_COLOR, values);
+    d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
 #else
     Q_UNUSED(r);
     Q_UNUSED(g);
@@ -2990,7 +2990,7 @@ void QOpenGLTexture::setBorderColor(uint r, uint g, uint b, uint a)
     d->borderColor.clear();
     for (int i = 0; i < 4; ++i)
         d->borderColor.append(QVariant(values[i]));
-    d->texFuncs->glTextureParameteriv(d->textureId, d->target, GL_TEXTURE_BORDER_COLOR, values);
+    d->texFuncs->glTextureParameteriv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
 #else
     Q_UNUSED(r);
     Q_UNUSED(g);
@@ -3087,7 +3087,7 @@ void QOpenGLTexture::setMinimumLevelOfDetail(float value)
     Q_ASSERT(d->textureId);
     Q_ASSERT(value < d->maxLevelOfDetail);
     d->minLevelOfDetail = value;
-    d->texFuncs->glTextureParameterf(d->textureId, d->target, GL_TEXTURE_MIN_LOD, value);
+    d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_LOD, value);
 #else
     Q_UNUSED(value);
     qWarning("QOpenGLTexture: Detail level is not supported");
@@ -3121,7 +3121,7 @@ void QOpenGLTexture::setMaximumLevelOfDetail(float value)
     Q_ASSERT(d->textureId);
     Q_ASSERT(value > d->minLevelOfDetail);
     d->maxLevelOfDetail = value;
-    d->texFuncs->glTextureParameterf(d->textureId, d->target, GL_TEXTURE_MAX_LOD, value);
+    d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LOD, value);
 #else
     Q_UNUSED(value);
     qWarning("QOpenGLTexture: Detail level is not supported");
@@ -3155,8 +3155,8 @@ void QOpenGLTexture::setLevelOfDetailRange(float min, float max)
     Q_ASSERT(min < max);
     d->minLevelOfDetail = min;
     d->maxLevelOfDetail = max;
-    d->texFuncs->glTextureParameterf(d->textureId, d->target, GL_TEXTURE_MIN_LOD, min);
-    d->texFuncs->glTextureParameterf(d->textureId, d->target, GL_TEXTURE_MAX_LOD, max);
+    d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MIN_LOD, min);
+    d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_MAX_LOD, max);
 #else
     Q_UNUSED(min);
     Q_UNUSED(max);
@@ -3189,7 +3189,7 @@ void QOpenGLTexture::setLevelofDetailBias(float bias)
     Q_ASSERT(d->texFuncs);
     Q_ASSERT(d->textureId);
     d->levelOfDetailBias = bias;
-    d->texFuncs->glTextureParameterf(d->textureId, d->target, GL_TEXTURE_LOD_BIAS, bias);
+    d->texFuncs->glTextureParameterf(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_LOD_BIAS, bias);
 #else
     Q_UNUSED(bias);
     qWarning("QOpenGLTexture: Detail level is not supported");
diff --git a/src/gui/opengl/qopengltexturehelper_p.h b/src/gui/opengl/qopengltexturehelper_p.h
index fa4bd8120a..07013882da 100644
--- a/src/gui/opengl/qopengltexturehelper_p.h
+++ b/src/gui/opengl/qopengltexturehelper_p.h
@@ -60,134 +60,134 @@ public:
     QOpenGLTextureHelper(QOpenGLContext *context);
 
     // DSA API
-    inline void glTextureParameteri(GLuint texture, GLenum target, GLenum pname, GLint param)
+    inline void glTextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
     {
-        (this->*TextureParameteri)(texture, target, pname, param);
+        (this->*TextureParameteri)(texture, target, bindingTarget, pname, param);
     }
 
-    inline void glTextureParameteriv(GLuint texture, GLenum target, GLenum pname, const GLint *params)
+    inline void glTextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
     {
-        (this->*TextureParameteriv)(texture, target, pname, params);
+        (this->*TextureParameteriv)(texture, target, bindingTarget, pname, params);
     }
 
-    inline void glTextureParameterf(GLuint texture, GLenum target, GLenum pname, GLfloat param)
+    inline void glTextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
     {
-        (this->*TextureParameterf)(texture, target, pname, param);
+        (this->*TextureParameterf)(texture, target, bindingTarget, pname, param);
     }
 
-    inline void glTextureParameterfv(GLuint texture, GLenum target, GLenum pname, const GLfloat *params)
+    inline void glTextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
     {
-        (this->*TextureParameterfv)(texture, target, pname, params);
+        (this->*TextureParameterfv)(texture, target, bindingTarget, pname, params);
     }
 
-    inline void glGenerateTextureMipmap(GLuint texture, GLenum target)
+    inline void glGenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
     {
-        (this->*GenerateTextureMipmap)(texture, target);
+        (this->*GenerateTextureMipmap)(texture, target, bindingTarget);
     }
 
-    inline void glTextureStorage3D(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat,
+    inline void glTextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
                                    GLsizei width, GLsizei height, GLsizei depth)
     {
-        (this->*TextureStorage3D)(texture, target, levels, internalFormat, width, height, depth);
+        (this->*TextureStorage3D)(texture, target, bindingTarget, levels, internalFormat, width, height, depth);
     }
 
-    inline void glTextureStorage2D(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat,
+    inline void glTextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
                                    GLsizei width, GLsizei height)
     {
-        (this->*TextureStorage2D)(texture, target, levels, internalFormat, width, height);
+        (this->*TextureStorage2D)(texture, target, bindingTarget, levels, internalFormat, width, height);
     }
 
-    inline void glTextureStorage1D(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat,
+    inline void glTextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
                                    GLsizei width)
     {
-        (this->*TextureStorage1D)(texture, target, levels, internalFormat, width);
+        (this->*TextureStorage1D)(texture, target, bindingTarget, levels, internalFormat, width);
     }
 
-    inline void glTextureStorage3DMultisample(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat,
+    inline void glTextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
                                               GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
     {
-        (this->*TextureStorage3DMultisample)(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
+        (this->*TextureStorage3DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, depth, fixedSampleLocations);
     }
 
-    inline void glTextureStorage2DMultisample(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat,
+    inline void glTextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
                                               GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
     {
-        (this->*TextureStorage2DMultisample)(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
+        (this->*TextureStorage2DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, fixedSampleLocations);
     }
 
-    inline void glTextureImage3D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void glTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                  GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
     {
-        (this->*TextureImage3D)(texture, target, level, internalFormat, width, height, depth, border, format, type, pixels);
+        (this->*TextureImage3D)(texture, target, bindingTarget, level, internalFormat, width, height, depth, border, format, type, pixels);
     }
 
-    inline void glTextureImage2D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void glTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                  GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
     {
-        (this->*TextureImage2D)(texture, target, level, internalFormat, width, height, border, format, type, pixels);
+        (this->*TextureImage2D)(texture, target, bindingTarget, level, internalFormat, width, height, border, format, type, pixels);
     }
 
-    inline void glTextureImage1D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void glTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                  GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
     {
-        (this->*TextureImage1D)(texture, target, level, internalFormat, width, border, format, type, pixels);
+        (this->*TextureImage1D)(texture, target, bindingTarget, level, internalFormat, width, border, format, type, pixels);
     }
 
-    inline void glTextureSubImage3D(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    inline void glTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
                                     GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type,
                                     const GLvoid *pixels, const QOpenGLPixelTransferOptions * const options = 0)
     {
         if (options) {
             QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
             setPixelUploadOptions(*options);
-            (this->*TextureSubImage3D)(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+            (this->*TextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
             setPixelUploadOptions(oldOptions);
         } else {
-            (this->*TextureSubImage3D)(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+            (this->*TextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
         }
     }
 
-    inline void glTextureSubImage2D(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    inline void glTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset,
                                     GLsizei width, GLsizei height, GLenum format, GLenum type,
                                     const GLvoid *pixels, const QOpenGLPixelTransferOptions * const options = 0)
     {
         if (options) {
             QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
             setPixelUploadOptions(*options);
-            (this->*TextureSubImage2D)(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
+            (this->*TextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, type, pixels);
             setPixelUploadOptions(oldOptions);
         } else {
-            (this->*TextureSubImage2D)(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
+            (this->*TextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, type, pixels);
         }
     }
 
-    inline void glTextureSubImage1D(GLuint texture, GLenum target, GLint level, GLint xoffset,
+    inline void glTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset,
                                     GLsizei width, GLenum format, GLenum type,
                                     const GLvoid *pixels, const QOpenGLPixelTransferOptions * const options = 0)
     {
         if (options) {
             QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
             setPixelUploadOptions(*options);
-            (this->*TextureSubImage1D)(texture, target, level, xoffset, width, format, type, pixels);
+            (this->*TextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, type, pixels);
             setPixelUploadOptions(oldOptions);
         } else {
-            (this->*TextureSubImage1D)(texture, target, level, xoffset, width, format, type, pixels);
+            (this->*TextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, type, pixels);
         }
     }
 
-    inline void glTextureImage3DMultisample(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat,
+    inline void glTextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
                                             GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
     {
-        (this->*TextureImage3DMultisample)(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
+        (this->*TextureImage3DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, depth, fixedSampleLocations);
     }
 
-    inline void glTextureImage2DMultisample(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat,
+    inline void glTextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
                                             GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
     {
-        (this->*TextureImage2DMultisample)(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
+        (this->*TextureImage2DMultisample)(texture, target, bindingTarget, samples, internalFormat, width, height, fixedSampleLocations);
     }
 
-    inline void glCompressedTextureSubImage1D(GLuint texture, GLenum target, GLint level,
+    inline void glCompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                               GLint xoffset, GLsizei width,
                                               GLenum format, GLsizei imageSize, const GLvoid *bits,
                                               const QOpenGLPixelTransferOptions * const options = 0)
@@ -195,14 +195,14 @@ public:
         if (options) {
             QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
             setPixelUploadOptions(*options);
-            (this->*CompressedTextureSubImage1D)(texture, target, level, xoffset, width, format, imageSize, bits);
+            (this->*CompressedTextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, imageSize, bits);
             setPixelUploadOptions(oldOptions);
         } else {
-            (this->*CompressedTextureSubImage1D)(texture, target, level, xoffset, width, format, imageSize, bits);
+            (this->*CompressedTextureSubImage1D)(texture, target, bindingTarget, level, xoffset, width, format, imageSize, bits);
         }
     }
 
-    inline void glCompressedTextureSubImage2D(GLuint texture, GLenum target, GLint level,
+    inline void glCompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                               GLint xoffset, GLint yoffset,
                                               GLsizei width, GLsizei height,
                                               GLenum format, GLsizei imageSize, const GLvoid *bits,
@@ -211,14 +211,14 @@ public:
         if (options) {
             QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
             setPixelUploadOptions(*options);
-            (this->*CompressedTextureSubImage2D)(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
+            (this->*CompressedTextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, imageSize, bits);
             setPixelUploadOptions(oldOptions);
         } else {
-            (this->*CompressedTextureSubImage2D)(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
+            (this->*CompressedTextureSubImage2D)(texture, target, bindingTarget, level, xoffset, yoffset, width, height, format, imageSize, bits);
         }
     }
 
-    inline void glCompressedTextureSubImage3D(GLuint texture, GLenum target, GLint level,
+    inline void glCompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                               GLint xoffset, GLint yoffset, GLint zoffset,
                                               GLsizei width, GLsizei height, GLsizei depth,
                                               GLenum format, GLsizei imageSize, const GLvoid *bits,
@@ -227,439 +227,463 @@ public:
         if (options) {
             QOpenGLPixelTransferOptions oldOptions = savePixelUploadOptions();
             setPixelUploadOptions(*options);
-            (this->*CompressedTextureSubImage3D)(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
+            (this->*CompressedTextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
             setPixelUploadOptions(oldOptions);
         } else {
-            (this->*CompressedTextureSubImage3D)(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
+            (this->*CompressedTextureSubImage3D)(texture, target, bindingTarget, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
         }
     }
 
-    inline void glCompressedTextureImage1D(GLuint texture, GLenum target, GLint level,
+    inline void glCompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                            GLenum internalFormat, GLsizei width,
                                            GLint border, GLsizei imageSize, const GLvoid *bits)
     {
-        (this->*CompressedTextureImage1D)(texture, target, level, internalFormat, width, border, imageSize, bits);
+        (this->*CompressedTextureImage1D)(texture, target, bindingTarget, level, internalFormat, width, border, imageSize, bits);
     }
 
-    inline void glCompressedTextureImage2D(GLuint texture, GLenum target, GLint level,
+    inline void glCompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                            GLenum internalFormat, GLsizei width, GLsizei height,
                                            GLint border, GLsizei imageSize, const GLvoid *bits)
     {
-        (this->*CompressedTextureImage2D)(texture, target, level, internalFormat, width, height, border, imageSize, bits);
+        (this->*CompressedTextureImage2D)(texture, target, bindingTarget, level, internalFormat, width, height, border, imageSize, bits);
     }
 
-    inline void glCompressedTextureImage3D(GLuint texture, GLenum target, GLint level,
+    inline void glCompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                            GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth,
                                            GLint border, GLsizei imageSize, const GLvoid *bits)
     {
-        (this->*CompressedTextureImage3D)(texture, target, level, internalFormat, width, height, depth, border, imageSize, bits);
+        (this->*CompressedTextureImage3D)(texture, target, bindingTarget, level, internalFormat, width, height, depth, border, imageSize, bits);
     }
 
 private:
 #if !defined(QT_OPENGL_ES_2)
     // DSA wrapper (so we can use pointer to member function as switch)
-    inline void dsa_TextureParameteri(GLuint texture, GLenum target, GLenum pname, GLint param)
+    inline void dsa_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
     {
+        Q_UNUSED(bindingTarget);
         TextureParameteriEXT(texture, target, pname, param);
     }
 
-    inline void dsa_TextureParameteriv(GLuint texture, GLenum target, GLenum pname, const GLint *params)
+    inline void dsa_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
     {
+        Q_UNUSED(bindingTarget);
         TextureParameterivEXT(texture, target, pname, params);
     }
 
-    inline void dsa_TextureParameterf(GLuint texture, GLenum target, GLenum pname, GLfloat param)
+    inline void dsa_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
     {
+        Q_UNUSED(bindingTarget);
         TextureParameterfEXT(texture, target, pname, param);
     }
 
-    inline void dsa_TextureParameterfv(GLuint texture, GLenum target, GLenum pname, const GLfloat *params)
+    inline void dsa_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
     {
+        Q_UNUSED(bindingTarget);
         TextureParameterfvEXT(texture, target, pname, params);
     }
 
-    inline void dsa_GenerateTextureMipmap(GLuint texture, GLenum target)
+    inline void dsa_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
     {
+        Q_UNUSED(bindingTarget);
         GenerateTextureMipmapEXT(texture, target);
     }
 
-    inline void dsa_TextureStorage3D(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat,
+    inline void dsa_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
                                      GLsizei width, GLsizei height, GLsizei depth)
     {
+        Q_UNUSED(bindingTarget);
         TextureStorage3DEXT(texture, target, levels, internalFormat, width, height, depth);
     }
 
-    inline void dsa_TextureStorage2D(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat,
+    inline void dsa_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
                                      GLsizei width, GLsizei height)
     {
+        Q_UNUSED(bindingTarget);
         TextureStorage2DEXT(texture, target, levels, internalFormat, width, height);
     }
 
-    inline void dsa_TextureStorage1D(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat,
+    inline void dsa_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat,
                                      GLsizei width)
     {
+        Q_UNUSED(bindingTarget);
         TextureStorage1DEXT(texture, target, levels, internalFormat, width);
     }
 
-    inline void dsa_TextureStorage3DMultisample(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat,
+    inline void dsa_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
                                                 GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
     {
+        Q_UNUSED(bindingTarget);
         TextureStorage3DMultisampleEXT(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
     }
 
-    inline void dsa_TextureStorage2DMultisample(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat,
+    inline void dsa_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat,
                                                 GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
     {
+        Q_UNUSED(bindingTarget);
         TextureStorage2DMultisampleEXT(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
     }
 
-    inline void dsa_TextureImage3D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void dsa_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                    GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
     {
+        Q_UNUSED(bindingTarget);
         TextureImage3DEXT(texture, target, level, internalFormat, width, height, depth, border, format, type, pixels);
     }
 
-    inline void dsa_TextureImage2D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void dsa_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                    GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
     {
+        Q_UNUSED(bindingTarget);
         TextureImage2DEXT(texture, target, level, internalFormat, width, height, border, format, type, pixels);
     }
 
-    inline void dsa_TextureImage1D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void dsa_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                    GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
     {
+        Q_UNUSED(bindingTarget);
         TextureImage1DEXT(texture, target, level, internalFormat, width, border, format, type, pixels);
     }
 
-    inline void dsa_TextureSubImage3D(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
+    inline void dsa_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset,
                                       GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
     {
+        Q_UNUSED(bindingTarget);
         TextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
     }
 
-    inline void dsa_TextureSubImage2D(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset,
+    inline void dsa_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset,
                                       GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
     {
+        Q_UNUSED(bindingTarget);
         TextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
     }
 
-    inline void dsa_TextureSubImage1D(GLuint texture, GLenum target, GLint level, GLint xoffset,
+    inline void dsa_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset,
                                       GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
     {
+        Q_UNUSED(bindingTarget);
         TextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);
     }
 
-    inline void dsa_TextureImage3DMultisample(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat,
+    inline void dsa_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
                                               GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
     {
+        Q_UNUSED(bindingTarget);
         TextureImage3DMultisampleNV(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
     }
 
-    inline void dsa_TextureImage2DMultisample(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat,
+    inline void dsa_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat,
                                               GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
     {
+        Q_UNUSED(bindingTarget);
         TextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
     }
 
-    inline void dsa_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLint level,
+    inline void dsa_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                                 GLint xoffset, GLsizei width,
                                                 GLenum format, GLsizei imageSize, const GLvoid *bits)
     {
+        Q_UNUSED(bindingTarget);
         CompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
     }
 
-    inline void dsa_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLint level,
+    inline void dsa_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                                 GLint xoffset, GLint yoffset,
                                                 GLsizei width, GLsizei height,
                                                 GLenum format, GLsizei imageSize, const GLvoid *bits)
     {
+        Q_UNUSED(bindingTarget);
         CompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
     }
 
-    inline void dsa_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLint level,
+    inline void dsa_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                                 GLint xoffset, GLint yoffset, GLint zoffset,
                                                 GLsizei width, GLsizei height, GLsizei depth,
                                                 GLenum format, GLsizei imageSize, const GLvoid *bits)
     {
+        Q_UNUSED(bindingTarget);
         CompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
     }
 
-    inline void dsa_CompressedTextureImage1D(GLuint texture, GLenum target, GLint level,
+    inline void dsa_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                              GLenum internalFormat, GLsizei width,
                                              GLint border, GLsizei imageSize, const GLvoid *bits)
     {
+        Q_UNUSED(bindingTarget);
         CompressedTextureImage1DEXT(texture, target, level, internalFormat, width, border, imageSize, bits);
     }
 
-    inline void dsa_CompressedTextureImage2D(GLuint texture, GLenum target, GLint level,
+    inline void dsa_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                              GLenum internalFormat, GLsizei width, GLsizei height,
                                              GLint border, GLsizei imageSize, const GLvoid *bits)
     {
+        Q_UNUSED(bindingTarget);
         CompressedTextureImage2DEXT(texture, target, level, internalFormat, width, height, border, imageSize, bits);
     }
 
-    inline void dsa_CompressedTextureImage3D(GLuint texture, GLenum target, GLint level,
+    inline void dsa_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                              GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth,
                                              GLint border, GLsizei imageSize, const GLvoid *bits)
     {
+        Q_UNUSED(bindingTarget);
         CompressedTextureImage3DEXT(texture, target, level, internalFormat, width, height, depth, border, imageSize, bits);
     }
 #endif
 
 
     // DSA-like API
-    inline void qt_TextureParameteri(GLuint texture, GLenum target, GLenum pname, GLint param)
+    inline void qt_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexParameteri(target, pname, param);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureParameteriv(GLuint texture, GLenum target, GLenum pname, const GLint *params)
+    inline void qt_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexParameteriv(target, pname, params);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureParameterf(GLuint texture, GLenum target, GLenum pname, GLfloat param)
+    inline void qt_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexParameterf(target, pname, param);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureParameterfv(GLuint texture, GLenum target, GLenum pname, const GLfloat *params)
+    inline void qt_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexParameterfv(target, pname, params);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_GenerateTextureMipmap(GLuint texture, GLenum target)
+    inline void qt_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glGenerateMipmap(target);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureStorage3D(GLuint texture, GLenum target, GLsizei levels,
+    inline void qt_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels,
                                     GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexStorage3D(target, levels, internalFormat, width, height, depth);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureStorage2D(GLuint texture, GLenum target, GLsizei levels,
+    inline void qt_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels,
                                     GLenum internalFormat, GLsizei width, GLsizei height)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexStorage2D(target, levels, internalFormat, width, height);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureStorage1D(GLuint texture, GLenum target, GLsizei levels,
+    inline void qt_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels,
                                     GLenum internalFormat, GLsizei width)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexStorage1D(target, levels, internalFormat, width);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureStorage3DMultisample(GLuint texture, GLenum target, GLsizei samples,
+    inline void qt_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
                                                GLenum internalFormat, GLsizei width, GLsizei height,
                                                GLsizei depth, GLboolean fixedSampleLocations)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexStorage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureStorage2DMultisample(GLuint texture, GLenum target, GLsizei samples,
+    inline void qt_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
                                                GLenum internalFormat, GLsizei width, GLsizei height,
                                                GLboolean fixedSampleLocations)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexStorage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureImage3D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void qt_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                   GLsizei width, GLsizei height, GLsizei depth,
                                   GLint border, GLenum format, GLenum type,
                                   const GLvoid *pixels)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureImage2D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void qt_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                   GLsizei width, GLsizei height,
                                   GLint border, GLenum format, GLenum type,
                                   const GLvoid *pixels)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureImage1D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void qt_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                   GLsizei width, GLint border, GLenum format, GLenum type,
                                   const GLvoid *pixels)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureSubImage3D(GLuint texture, GLenum target, GLint level,
+    inline void qt_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                      GLint xoffset, GLint yoffset, GLint zoffset,
                                      GLsizei width, GLsizei height, GLsizei depth,
                                      GLenum format, GLenum type, const GLvoid *pixels)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureSubImage2D(GLuint texture, GLenum target, GLint level,
+    inline void qt_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                      GLint xoffset, GLint yoffset,
                                      GLsizei width, GLsizei height,
                                      GLenum format, GLenum type, const GLvoid *pixels)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureSubImage1D(GLuint texture, GLenum target, GLint level,
+    inline void qt_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                      GLint xoffset, GLsizei width,
                                      GLenum format, GLenum type, const GLvoid *pixels)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureImage3DMultisample(GLuint texture, GLenum target, GLsizei samples,
+    inline void qt_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
                                              GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth,
                                              GLboolean fixedSampleLocations)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_TextureImage2DMultisample(GLuint texture, GLenum target, GLsizei samples,
+    inline void qt_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples,
                                              GLint internalFormat, GLsizei width, GLsizei height,
                                              GLboolean fixedSampleLocations)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLint level,
+    inline void qt_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                                GLint xoffset, GLsizei width, GLenum format,
                                                GLsizei imageSize, const GLvoid *bits)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, bits);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLint level,
+    inline void qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                                GLint xoffset, GLint yoffset,
                                                GLsizei width, GLsizei height,
                                                GLenum format, GLsizei imageSize, const GLvoid *bits)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, bits);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLint level,
+    inline void qt_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level,
                                                GLint xoffset, GLint yoffset, GLint zoffset,
                                                GLsizei width, GLsizei height, GLsizei depth,
                                                GLenum format, GLsizei imageSize, const GLvoid *bits)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_CompressedTextureImage1D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void qt_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                             GLsizei width, GLint border,
                                             GLsizei imageSize, const GLvoid *bits)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, bits);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_CompressedTextureImage2D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void qt_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                             GLsizei width, GLsizei height, GLint border,
                                             GLsizei imageSize, const GLvoid *bits)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, bits);
         glBindTexture(target, oldTexture);
     }
 
-    inline void qt_CompressedTextureImage3D(GLuint texture, GLenum target, GLint level, GLenum internalFormat,
+    inline void qt_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat,
                                             GLsizei width, GLsizei height, GLsizei depth, GLint border,
                                             GLsizei imageSize, const GLvoid *bits)
     {
         GLint oldTexture;
-        glGetIntegerv(target, &oldTexture);
+        glGetIntegerv(bindingTarget, &oldTexture);
         glBindTexture(target, texture);
         glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, bits);
         glBindTexture(target, oldTexture);
@@ -937,30 +961,30 @@ public:
 
 private:
     // Typedefs and pointers to member functions used to switch between EXT_direct_state_access and our own emulated DSA
-    typedef void (QOpenGLTextureHelper::*TextureParameteriMemberFunc)(GLuint texture, GLenum target, GLenum pname, GLint param);
-    typedef void (QOpenGLTextureHelper::*TextureParameterivMemberFunc)(GLuint texture, GLenum target, GLenum pname, const GLint *params);
-    typedef void (QOpenGLTextureHelper::*TextureParameterfMemberFunc)(GLuint texture, GLenum target, GLenum pname, GLfloat param);
-    typedef void (QOpenGLTextureHelper::*TextureParameterfvMemberFunc)(GLuint texture, GLenum target, GLenum pname, const GLfloat *params);
-    typedef void (QOpenGLTextureHelper::*GenerateTextureMipmapMemberFunc)(GLuint texture, GLenum target);
-    typedef void (QOpenGLTextureHelper::*TextureStorage3DMemberFunc)(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
-    typedef void (QOpenGLTextureHelper::*TextureStorage2DMemberFunc)(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height);
-    typedef void (QOpenGLTextureHelper::*TextureStorage1DMemberFunc)(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width);
-    typedef void (QOpenGLTextureHelper::*TextureStorage3DMultisampleMemberFunc)(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*TextureStorage2DMultisampleMemberFunc)(GLuint texture, GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*TextureImage3DMemberFunc)(GLuint texture, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureImage2DMemberFunc)(GLuint texture, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureImage1DMemberFunc)(GLuint texture, GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureSubImage3DMemberFunc)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureSubImage2DMemberFunc)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureSubImage1DMemberFunc)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    typedef void (QOpenGLTextureHelper::*TextureImage3DMultisampleMemberFunc)(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*TextureImage2DMultisampleMemberFunc)(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage1DMemberFunc)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage2DMemberFunc)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage3DMemberFunc)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureImage1DMemberFunc)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureImage2DMemberFunc)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
-    typedef void (QOpenGLTextureHelper::*CompressedTextureImage3DMemberFunc)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
+    typedef void (QOpenGLTextureHelper::*TextureParameteriMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param);
+    typedef void (QOpenGLTextureHelper::*TextureParameterivMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params);
+    typedef void (QOpenGLTextureHelper::*TextureParameterfMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param);
+    typedef void (QOpenGLTextureHelper::*TextureParameterfvMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params);
+    typedef void (QOpenGLTextureHelper::*GenerateTextureMipmapMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget);
+    typedef void (QOpenGLTextureHelper::*TextureStorage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth);
+    typedef void (QOpenGLTextureHelper::*TextureStorage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height);
+    typedef void (QOpenGLTextureHelper::*TextureStorage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width);
+    typedef void (QOpenGLTextureHelper::*TextureStorage3DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
+    typedef void (QOpenGLTextureHelper::*TextureStorage2DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
+    typedef void (QOpenGLTextureHelper::*TextureImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+    typedef void (QOpenGLTextureHelper::*TextureImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+    typedef void (QOpenGLTextureHelper::*TextureImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+    typedef void (QOpenGLTextureHelper::*TextureSubImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+    typedef void (QOpenGLTextureHelper::*TextureSubImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+    typedef void (QOpenGLTextureHelper::*TextureSubImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+    typedef void (QOpenGLTextureHelper::*TextureImage3DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations);
+    typedef void (QOpenGLTextureHelper::*TextureImage2DMultisampleMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
+    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits);
+    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits);
+    typedef void (QOpenGLTextureHelper::*CompressedTextureSubImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits);
+    typedef void (QOpenGLTextureHelper::*CompressedTextureImage1DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits);
+    typedef void (QOpenGLTextureHelper::*CompressedTextureImage2DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits);
+    typedef void (QOpenGLTextureHelper::*CompressedTextureImage3DMemberFunc)(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits);
 
 
     TextureParameteriMemberFunc TextureParameteri;