Add wrappers for glEnableVertexAttrib and glVertexAttrib*Pointer

Needed to work around QTBUG-43199 to be able to specify integer
vertex attributes such as joint indices.

Change-Id: I39ab83e881b6afb75467c76b56125917013b3bca
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

4 files changed, 350 insertions, 4 deletions

diff --git a/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp b/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp
index 473e43d09..4a393c99f 100644
--- a/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp
+++ b/tests/auto/render/graphicshelpergl2/tst_graphicshelpergl2.cpp
@@ -33,8 +33,10 @@
 #include <Qt3DRender/private/attachmentpack_p.h>
 #include <QtOpenGLExtensions/QOpenGLExtensions>
 #include <QOpenGLContext>
+#include <QOpenGLBuffer>
 #include <QOpenGLFunctions_2_0>
 #include <QOpenGLShaderProgram>
+#include <QOpenGLVertexArrayObject>
 #include <QSurfaceFormat>
 
 #ifndef QT_OPENGL_ES_2
@@ -592,6 +594,33 @@ private Q_SLOTS:
         // Not supported by GL2
     }
 
+    void enableVertexAttribute()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 2.0 functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCode);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeSamplers);
+        QVERIFY(shaderProgram.link());
+        shaderProgram.bind();
+
+        // WHEN
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void frontFace()
     {
         if (!m_initializationSuccessful)
@@ -993,6 +1022,51 @@ private Q_SLOTS:
         // Not available in 3.2
     }
 
+    void vertexAttributePointer()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCode);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeSamplers);
+        QVERIFY(shaderProgram.link());
+
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+
+        const int vertexCount = 99;
+        QOpenGLBuffer positionBuffer(QOpenGLBuffer::VertexBuffer);
+        positionBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        positionBuffer.create();
+        positionBuffer.bind();
+        positionBuffer.allocate(vertexCount * sizeof(QVector3D));
+
+        QOpenGLBuffer texCoordBuffer(QOpenGLBuffer::VertexBuffer);
+        texCoordBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        texCoordBuffer.create();
+        texCoordBuffer.allocate(vertexCount * sizeof(QVector2D));
+
+        // WHEN
+        shaderProgram.bind();
+        positionBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC3, positionLocation, 3, GL_FLOAT, GL_TRUE, 0, 0);
+
+        texCoordBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC2, texCoordLocation, 2, GL_FLOAT, GL_TRUE, 0, 0);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void glUniform1fv()
     {
         if (!m_initializationSuccessful)
diff --git a/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp b/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
index b66192835..38b566142 100644
--- a/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
+++ b/tests/auto/render/graphicshelpergl3_2/tst_graphicshelpergl3_2.cpp
@@ -31,8 +31,10 @@
 #include <Qt3DRender/private/uniform_p.h>
 #include <Qt3DRender/private/graphicshelpergl3_2_p.h>
 #include <Qt3DRender/private/attachmentpack_p.h>
+#include <QOpenGLBuffer>
 #include <QOpenGLFunctions_3_2_Core>
 #include <QOpenGLShaderProgram>
+#include <QOpenGLVertexArrayObject>
 #include <QSurfaceFormat>
 
 #if !defined(QT_OPENGL_ES_2) && defined(QT_OPENGL_3_2)
@@ -139,6 +141,7 @@ const QByteArray fragCodeUniformsFloatMatrices = QByteArrayLiteral(
 const QByteArray fragCodeUniformBuffer = QByteArrayLiteral(
             "#version 150 core\n" \
             "out vec4 color;\n" \
+            "in vec2 texCoord;\n" \
             "flat in int colorIndex;\n" \
             "uniform ColorArray\n" \
             "{\n" \
@@ -146,7 +149,7 @@ const QByteArray fragCodeUniformBuffer = QByteArrayLiteral(
             "};\n" \
             "void main()\n" \
             "{\n" \
-            "   color = colors[colorIndex];\n" \
+            "   color = colors[colorIndex] + vec4(texCoord.s, texCoord.t, 0.0, 1.0);\n" \
             "}\n");
 
 const QByteArray fragCodeSamplers = QByteArrayLiteral(
@@ -803,6 +806,35 @@ private Q_SLOTS:
         m_func->glDisable(GL_PRIMITIVE_RESTART);
     }
 
+    void enableVertexAttribute()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 3.2 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCodeUniformBuffer);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeUniformBuffer);
+        QVERIFY(shaderProgram.link());
+        shaderProgram.bind();
+
+        // WHEN
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        GLint colorIndexLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexColorIndex");
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void frontFace()
     {
         if (!m_initializationSuccessful)
@@ -1298,6 +1330,61 @@ private Q_SLOTS:
         // Not available in 3.2
     }
 
+    void vertexAttributePointer()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCodeUniformBuffer);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeUniformBuffer);
+        QVERIFY(shaderProgram.link());
+
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        GLint colorIndexLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexColorIndex");
+
+        const int vertexCount = 99;
+        QOpenGLBuffer positionBuffer(QOpenGLBuffer::VertexBuffer);
+        positionBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        positionBuffer.create();
+        positionBuffer.bind();
+        positionBuffer.allocate(vertexCount * sizeof(QVector3D));
+
+        QOpenGLBuffer texCoordBuffer(QOpenGLBuffer::VertexBuffer);
+        texCoordBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        texCoordBuffer.create();
+        texCoordBuffer.allocate(vertexCount * sizeof(QVector2D));
+
+        QOpenGLBuffer colorIndexBuffer(QOpenGLBuffer::VertexBuffer);
+        colorIndexBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        colorIndexBuffer.create();
+        colorIndexBuffer.allocate(vertexCount * sizeof(int));
+
+        // WHEN
+        shaderProgram.bind();
+        positionBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC3, positionLocation, 3, GL_FLOAT, GL_TRUE, 0, 0);
+
+        texCoordBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC2, texCoordLocation, 2, GL_FLOAT, GL_TRUE, 0, 0);
+
+        colorIndexBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+        m_glHelper.vertexAttributePointer(GL_INT, colorIndexLocation, 1, GL_INT, GL_TRUE, 0, 0);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void glUniform1fv()
     {
         if (!m_initializationSuccessful)
diff --git a/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp b/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
index b7cc1cdac..b76287844 100644
--- a/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
+++ b/tests/auto/render/graphicshelpergl3_3/tst_graphicshelpergl3_3.cpp
@@ -31,8 +31,10 @@
 #include <Qt3DRender/private/uniform_p.h>
 #include <Qt3DRender/private/graphicshelpergl3_3_p.h>
 #include <Qt3DRender/private/attachmentpack_p.h>
+#include <QOpenGLBuffer>
 #include <QOpenGLFunctions_3_3_Core>
 #include <QOpenGLShaderProgram>
+#include <QOpenGLVertexArrayObject>
 
 #if !defined(QT_OPENGL_ES_2) && defined(QT_OPENGL_3_2)
 
@@ -138,6 +140,7 @@ const QByteArray fragCodeUniformsFloatMatrices = QByteArrayLiteral(
 const QByteArray fragCodeUniformBuffer = QByteArrayLiteral(
             "#version 330 core\n" \
             "out vec4 color;\n" \
+            "in vec2 texCoord;\n" \
             "flat in int colorIndex;\n" \
             "uniform ColorArray\n" \
             "{\n" \
@@ -145,7 +148,7 @@ const QByteArray fragCodeUniformBuffer = QByteArrayLiteral(
             "};\n" \
             "void main()\n" \
             "{\n" \
-            "   color = colors[colorIndex];\n" \
+            "   color = colors[colorIndex] + vec4(texCoord.s, texCoord.t, 0.0, 1.0);\n" \
             "}\n");
 
 const QByteArray fragCodeSamplers = QByteArrayLiteral(
@@ -902,6 +905,35 @@ private Q_SLOTS:
         m_func->glDisable(GL_PRIMITIVE_RESTART);
     }
 
+    void enableVertexAttribute()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 3.3 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCodeUniformBuffer);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeUniformBuffer);
+        QVERIFY(shaderProgram.link());
+        shaderProgram.bind();
+
+        // WHEN
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        GLint colorIndexLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexColorIndex");
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void frontFace()
     {
         if (!m_initializationSuccessful)
@@ -1397,6 +1429,61 @@ private Q_SLOTS:
             QSKIP("Initialization failed, OpenGL 3.3 Core functions not supported");
     }
 
+    void vertexAttributePointer()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCodeUniformBuffer);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeUniformBuffer);
+        QVERIFY(shaderProgram.link());
+
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        GLint colorIndexLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexColorIndex");
+
+        const int vertexCount = 99;
+        QOpenGLBuffer positionBuffer(QOpenGLBuffer::VertexBuffer);
+        positionBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        positionBuffer.create();
+        positionBuffer.bind();
+        positionBuffer.allocate(vertexCount * sizeof(QVector3D));
+
+        QOpenGLBuffer texCoordBuffer(QOpenGLBuffer::VertexBuffer);
+        texCoordBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        texCoordBuffer.create();
+        texCoordBuffer.allocate(vertexCount * sizeof(QVector2D));
+
+        QOpenGLBuffer colorIndexBuffer(QOpenGLBuffer::VertexBuffer);
+        colorIndexBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        colorIndexBuffer.create();
+        colorIndexBuffer.allocate(vertexCount * sizeof(int));
+
+        // WHEN
+        shaderProgram.bind();
+        positionBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC3, positionLocation, 3, GL_FLOAT, GL_TRUE, 0, 0);
+
+        texCoordBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC2, texCoordLocation, 2, GL_FLOAT, GL_TRUE, 0, 0);
+
+        colorIndexBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+        m_glHelper.vertexAttributePointer(GL_INT, colorIndexLocation, 1, GL_INT, GL_TRUE, 0, 0);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void glUniform1fv()
     {
         if (!m_initializationSuccessful)
diff --git a/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp b/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp
index 0ee14841c..91fe3d3d4 100644
--- a/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp
+++ b/tests/auto/render/graphicshelpergl4/tst_graphicshelpergl4.cpp
@@ -31,8 +31,10 @@
 #include <Qt3DRender/private/uniform_p.h>
 #include <Qt3DRender/private/graphicshelpergl4_p.h>
 #include <Qt3DRender/private/attachmentpack_p.h>
+#include <QOpenGLBuffer>
 #include <QOpenGLFunctions_4_3_Core>
 #include <QOpenGLShaderProgram>
+#include <QOpenGLVertexArrayObject>
 #include <QSurfaceFormat>
 
 #if !defined(QT_OPENGL_ES_2) && defined(QT_OPENGL_4_3)
@@ -60,11 +62,12 @@ const QByteArray vertCodeUniformBuffer = QByteArrayLiteral(
             "layout(location = 1) in vec3 vertexPosition;\n" \
             "layout(location = 2) in vec2 vertexTexCoord;\n" \
             "layout(location = 3) in int vertexColorIndex;\n" \
+            "layout(location = 4) in double vertexTexCoordScale;\n" \
             "out vec2 texCoord;\n" \
             "flat out int colorIndex;\n" \
             "void main()\n" \
             "{\n" \
-            "   texCoord = vertexTexCoord;\n" \
+            "   texCoord = vec2(vertexTexCoordScale * vertexTexCoord);\n" \
             "   colorIndex = vertexColorIndex;\n" \
             "   gl_Position = vec4(vertexPosition, 1.0);\n" \
             "}\n");
@@ -139,6 +142,7 @@ const QByteArray fragCodeUniformsFloatMatrices = QByteArrayLiteral(
 const QByteArray fragCodeUniformBuffer = QByteArrayLiteral(
             "#version 430 core\n" \
             "out vec4 color;\n" \
+            "in vec2 texCoord;\n" \
             "flat in int colorIndex;\n" \
             "layout(binding = 2, std140) uniform ColorArray\n" \
             "{\n" \
@@ -146,7 +150,7 @@ const QByteArray fragCodeUniformBuffer = QByteArrayLiteral(
             "};\n" \
             "void main()\n" \
             "{\n" \
-            "   color = colors[colorIndex];\n" \
+            "   color = colors[colorIndex] + vec4(texCoord.s, texCoord.t, 0.0, 1.0);\n" \
             "}\n");
 
 const QByteArray fragCodeSamplers = QByteArrayLiteral(
@@ -1000,6 +1004,35 @@ private Q_SLOTS:
         m_func->glDisable(GL_PRIMITIVE_RESTART);
     }
 
+    void enableVertexAttribute()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCodeUniformBuffer);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeUniformBuffer);
+        QVERIFY(shaderProgram.link());
+        shaderProgram.bind();
+
+        // WHEN
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        GLint colorIndexLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexColorIndex");
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void frontFace()
     {
         if (!m_initializationSuccessful)
@@ -1487,6 +1520,71 @@ private Q_SLOTS:
             QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
     }
 
+    void vertexAttributePointer()
+    {
+        if (!m_initializationSuccessful)
+            QSKIP("Initialization failed, OpenGL 4.3 Core functions not supported");
+
+        // GIVEN
+        QOpenGLVertexArrayObject vao;
+        vao.create();
+        QOpenGLVertexArrayObject::Binder binder(&vao);
+
+        QOpenGLShaderProgram shaderProgram;
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex, vertCodeUniformBuffer);
+        shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment, fragCodeUniformBuffer);
+        QVERIFY(shaderProgram.link());
+
+        GLint positionLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexPosition");
+        GLint texCoordLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoord");
+        GLint colorIndexLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexColorIndex");
+        GLint texCoordScaleLocation = m_func->glGetAttribLocation(shaderProgram.programId(), "vertexTexCoordScale");
+
+        const int vertexCount = 99;
+        QOpenGLBuffer positionBuffer(QOpenGLBuffer::VertexBuffer);
+        positionBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        positionBuffer.create();
+        positionBuffer.bind();
+        positionBuffer.allocate(vertexCount * sizeof(QVector3D));
+
+        QOpenGLBuffer texCoordBuffer(QOpenGLBuffer::VertexBuffer);
+        texCoordBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        texCoordBuffer.create();
+        texCoordBuffer.allocate(vertexCount * sizeof(QVector2D));
+
+        QOpenGLBuffer colorIndexBuffer(QOpenGLBuffer::VertexBuffer);
+        colorIndexBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        colorIndexBuffer.create();
+        colorIndexBuffer.allocate(vertexCount * sizeof(int));
+
+        QOpenGLBuffer scaleBuffer(QOpenGLBuffer::VertexBuffer);
+        scaleBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
+        scaleBuffer.create();
+        scaleBuffer.allocate(vertexCount * sizeof(double));
+
+        // WHEN
+        shaderProgram.bind();
+        positionBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(positionLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC3, positionLocation, 3, GL_FLOAT, GL_TRUE, 0, 0);
+
+        texCoordBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(texCoordLocation);
+        m_glHelper.vertexAttributePointer(GL_FLOAT_VEC2, texCoordLocation, 2, GL_FLOAT, GL_TRUE, 0, 0);
+
+        colorIndexBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+        m_glHelper.vertexAttributePointer(GL_INT, colorIndexLocation, 1, GL_INT, GL_TRUE, 0, 0);
+
+        scaleBuffer.bind();
+        m_glHelper.enableVertexAttributeArray(colorIndexLocation);
+        m_glHelper.vertexAttributePointer(GL_DOUBLE, texCoordScaleLocation, 1, GL_DOUBLE, GL_TRUE, 0, 0);
+
+        // THEN
+        const GLint error = m_func->glGetError();
+        QVERIFY(error == 0);
+    }
+
     void glUniform1fv()
     {
         if (!m_initializationSuccessful)