Expand the SubData benchmark.

tests/perf_tests/BufferSubData.cpp

@@ -9,6 +9,121 @@
 #include <cassert>
 #include <sstream>
 
+namespace
+{
+
+GLfloat *GetFloatData(GLint componentCount)
+{
+    static GLfloat vertices2[] =
+    {
+        1, 2,
+        0, 0,
+        2, 0,
+    };
+
+    static GLfloat vertices3[] =
+    {
+        1, 2, 1,
+        0, 0, 1,
+        2, 0, 1,
+    };
+
+    static GLfloat vertices4[] =
+    {
+        1, 2, 1, 3,
+        0, 0, 1, 3,
+        2, 0, 1, 3,
+    };
+
+    switch (componentCount)
+    {
+      case 2: return vertices2;
+      case 3: return vertices3;
+      case 4: return vertices4;
+      default: return NULL;
+    }
+}
+
+template <class T>
+GLsizeiptr GetNormalizedData(GLsizeiptr numElements, GLfloat *floatData, std::vector<uint8_t> *data)
+{
+    GLsizeiptr triDataSize = sizeof(T) * numElements;
+    data->resize(triDataSize);
+
+    T *destPtr = reinterpret_cast<T*>(data->data());
+
+    for (GLsizeiptr dataIndex = 0; dataIndex < numElements; dataIndex++)
+    {
+        GLfloat scaled = floatData[dataIndex] * 0.25f;
+        destPtr[dataIndex] = static_cast<T>(scaled * static_cast<GLfloat>(std::numeric_limits<T>::max()));
+    }
+
+    return triDataSize;
+}
+
+template <class T>
+GLsizeiptr GetIntData(GLsizeiptr numElements, GLfloat *floatData, std::vector<uint8_t> *data)
+{
+    GLsizeiptr triDataSize = sizeof(T) * numElements;
+    data->resize(triDataSize);
+
+    T *destPtr = reinterpret_cast<T*>(data->data());
+
+    for (GLsizeiptr dataIndex = 0; dataIndex < numElements; dataIndex++)
+    {
+        destPtr[dataIndex] = static_cast<T>(floatData[dataIndex]);
+    }
+
+    return triDataSize;
+}
+
+GLsizeiptr GetVertexData(GLenum type, GLint componentCount, GLboolean normalized, std::vector<uint8_t> *data)
+{
+    GLsizeiptr triDataSize = 0;
+    GLfloat *floatData = GetFloatData(componentCount);
+
+    if (type == GL_FLOAT)
+    {
+        triDataSize = sizeof(GLfloat) * componentCount * 3;
+        data->resize(triDataSize);
+        memcpy(data->data(), floatData, triDataSize);
+    }
+    else if (normalized == GL_TRUE)
+    {
+        GLsizeiptr numElements = componentCount * 3;
+
+        switch (type)
+        {
+          case GL_BYTE:           triDataSize = GetNormalizedData<GLbyte>(numElements, floatData, data); break;
+          case GL_SHORT:          triDataSize = GetNormalizedData<GLshort>(numElements, floatData, data); break;
+          case GL_INT:            triDataSize = GetNormalizedData<GLint>(numElements, floatData, data); break;
+          case GL_UNSIGNED_BYTE:  triDataSize = GetNormalizedData<GLubyte>(numElements, floatData, data); break;
+          case GL_UNSIGNED_SHORT: triDataSize = GetNormalizedData<GLushort>(numElements, floatData, data); break;
+          case GL_UNSIGNED_INT:   triDataSize = GetNormalizedData<GLuint>(numElements, floatData, data); break;
+          default: assert(0);
+        }
+    }
+    else
+    {
+        GLsizeiptr numElements = componentCount * 3;
+
+        switch (type)
+        {
+          case GL_BYTE:           triDataSize = GetIntData<GLbyte>(numElements, floatData, data); break;
+          case GL_SHORT:          triDataSize = GetIntData<GLshort>(numElements, floatData, data); break;
+          case GL_INT:            triDataSize = GetIntData<GLint>(numElements, floatData, data); break;
+          case GL_UNSIGNED_BYTE:  triDataSize = GetIntData<GLubyte>(numElements, floatData, data); break;
+          case GL_UNSIGNED_SHORT: triDataSize = GetIntData<GLushort>(numElements, floatData, data); break;
+          case GL_UNSIGNED_INT:   triDataSize = GetIntData<GLuint>(numElements, floatData, data); break;
+          default: assert(0);
+        }
+    }
+
+    return triDataSize;
+}
+
+}
+
 std::string BufferSubDataParams::name() const
 {
     std::stringstream strstr;
@@ -24,6 +139,11 @@ std::string BufferSubDataParams::name() const
 
     strstr << " - ";
 
+    if (vertexNormalized)
+    {
+        strstr << "Norm";
+    }
+
     switch (vertexType)
     {
       case GL_FLOAT: strstr << "Float"; break;
@@ -59,10 +179,12 @@ bool BufferSubDataBenchmark::initializeBenchmark()
 {
     const std::string vs = SHADER_SOURCE
     (
-        attribute vec4 vPosition;
+        attribute vec2 vPosition;
+        uniform float uScale;
+        uniform float uOffset;
         void main()
         {
-            gl_Position = vPosition;
+            gl_Position = vec4(vPosition * vec2(uScale) - vec2(uOffset), 0, 1);
         }
     );
 
@@ -96,52 +218,33 @@ bool BufferSubDataBenchmark::initializeBenchmark()
 
     mUpdateData = new uint8_t[mParams.updateSize];
 
-    GLfloat vertices2[] =
-    {
-        0.0f, 0.5f,
-        -0.5f, -0.5f,
-        0.5f, -0.5f,
-    };
-
-    GLfloat vertices3[] =
-    {
-        0.0f, 0.5f, 0.0f,
-        -0.5f, -0.5f, 0.0f,
-        0.5f, -0.5f, 0.0f,
-    };
-
-    GLfloat vertices4[] =
-    {
-        0.0f, 0.5f, 0.0f, 1.0f,
-        -0.5f, -0.5f, 0.0f, 1.0f,
-        0.5f, -0.5f, 0.0f, 1.0f,
-    };
-
-    float *vertexData = NULL;
+    std::vector<uint8_t> data;
+    GLsizei triDataSize = GetVertexData(mParams.vertexType,
+                                        mParams.vertexComponentCount,
+                                        mParams.vertexNormalized, &data);
 
-    switch (mParams.vertexComponentCount)
-    {
-      case 2: vertexData = vertices2; break;
-      case 3: vertexData = vertices3; break;
-      case 4: vertexData = vertices4; break;
-      default: break;
-    }
-
-    assert(vertexData != NULL);
-
-    GLsizeiptr vertexDataSize = sizeof(GLfloat) * mParams.vertexComponentCount;
-    GLsizeiptr triDataSize = vertexDataSize * 3;
     mNumTris = mParams.updateSize / triDataSize;
-    int offset = 0;
-    for (int i = 0; i < mNumTris; ++i)
+    for (int i = 0, offset = 0; i < mNumTris; ++i)
     {
-        memcpy(mUpdateData + offset, vertexData, triDataSize);
+        memcpy(mUpdateData + offset, data.data(), triDataSize);
         offset += triDataSize;
     }
 
     // Set the viewport
     glViewport(0, 0, getWindow()->getWidth(), getWindow()->getHeight());
 
+    GLfloat scale = 0.5f;
+    GLfloat offset = 0.5f;
+
+    if (mParams.vertexNormalized == GL_TRUE)
+    {
+        scale = 2.0f;
+        offset = 0.5f;
+    }
+
+    glUniform1f(glGetUniformLocation(mProgram, "uScale"), scale);
+    glUniform1f(glGetUniformLocation(mProgram, "uOffset"), offset);
+
     GLenum glErr = glGetError();
     if (glErr != GL_NO_ERROR)
     {