use QOpenGLBuffer for color and vector data for waveformrenderers

src/waveform/renderers/allshader/vertexdata.h → src/waveform/renderers/allshader/vectordata.h

@@ -4,10 +4,10 @@
 #include <QVector>
 
 namespace allshader {
-class VertexData;
+class VectorData;
 }
 
-class allshader::VertexData {
+class allshader::VectorData {
     QVector<QVector2D> mData;
 
   public:

src/waveform/renderers/allshader/vertexbuffer.h

@@ -0,0 +1,186 @@
+#pragma once
+
+#include <QOpenGLBuffer>
+#include <cassert>
+
+namespace allshader {
+class VertexBuffer;
+class Vector2DVertexBuffer;
+class Vector2DRGBVertexBuffer;
+class Vector2DRGBAVertexBuffer;
+}
+
+class allshader::VertexBuffer : public QOpenGLBuffer {
+  public:
+    VertexBuffer(int tupleSize)
+            : QOpenGLBuffer(QOpenGLBuffer::VertexBuffer), m_tupleSize(tupleSize) {
+    }
+
+    void reserve(int count) {
+        int nBytes = count * stride() * sizeof(float);
+        if (nBytes > m_allocatedBytes) {
+            allocate(nBytes);
+            m_allocatedBytes = nBytes;
+        }
+    }
+
+    void mapForWrite() {
+        void* ptr = QOpenGLBuffer::map(QOpenGLBuffer::WriteOnly);
+        assert(ptr);
+        m_pMapped = static_cast<float*>(ptr);
+        m_valueIndex = 0;
+    }
+
+    void setIndex(int index) { // in amount of tuples
+        m_valueIndex = index * m_tupleSize;
+    }
+
+    int tupleSize() const { // in amount of floats
+        return m_tupleSize;
+    }
+
+    int size() const { // in tuples
+        return m_valueIndex / m_tupleSize;
+    }
+
+    int stride() const { // in bytes
+        return m_tupleSize * sizeof(float);
+    }
+
+  protected:
+    const int m_tupleSize;
+    int m_allocatedBytes{};
+    float* m_pMapped{};
+    int m_valueIndex{}; // index into m_pMapped, in amount of floats
+};
+
+class allshader::Vector2DVertexBuffer : public allshader::VertexBuffer {
+  public:
+    Vector2DVertexBuffer()
+            : VertexBuffer{2} {
+    }
+
+    constexpr int offset() const {
+        return 0;
+    }
+
+    void add(float x, float y) {
+        m_pMapped[m_valueIndex++] = x;
+        m_pMapped[m_valueIndex++] = y;
+    }
+
+    void addRectangle(float x1, float y1, float x2, float y2) {
+        add(x1, y1);
+        add(x2, y1);
+        add(x1, y2);
+
+        add(x1, y2);
+        add(x2, y2);
+        add(x2, y1);
+    }
+};
+
+class allshader::Vector2DRGBVertexBuffer : public VertexBuffer {
+  public:
+    Vector2DRGBVertexBuffer()
+            : VertexBuffer{positionTupleSize() + colorTupleSize()} {
+    }
+
+    constexpr int positionOffset() const {
+        return 0;
+    }
+
+    constexpr int positionTupleSize() const {
+        return 2;
+    }
+
+    constexpr int colorOffset() const {
+        return positionTupleSize() * sizeof(float);
+    }
+
+    constexpr int colorTupleSize() const {
+        return 3;
+    }
+
+    void add(float x, float y, float r, float g, float b) {
+        m_pMapped[m_valueIndex++] = x;
+        m_pMapped[m_valueIndex++] = y;
+
+        m_pMapped[m_valueIndex++] = r;
+        m_pMapped[m_valueIndex++] = g;
+        m_pMapped[m_valueIndex++] = b;
+    }
+
+    void addRectangle(float x1, float y1, float x2, float y2, float r, float g, float b) {
+        add(x1, y1, r, g, b);
+        add(x2, y1, r, g, b);
+        add(x1, y2, r, g, b);
+
+        add(x1, y2, r, g, b);
+        add(x2, y2, r, g, b);
+        add(x2, y1, r, g, b);
+    }
+};
+
+class allshader::Vector2DRGBAVertexBuffer : public VertexBuffer {
+  public:
+    Vector2DRGBAVertexBuffer()
+            : VertexBuffer{positionTupleSize() + colorTupleSize()} {
+    }
+
+    constexpr int positionOffset() const {
+        return 0;
+    }
+
+    constexpr int positionTupleSize() const {
+        return 2;
+    }
+
+    constexpr int colorOffset() const {
+        return positionTupleSize() * sizeof(float);
+    }
+
+    constexpr int colorTupleSize() const {
+        return 4;
+    }
+
+    void add(float x, float y, float r, float g, float b, float a) {
+        m_pMapped[m_valueIndex++] = x;
+        m_pMapped[m_valueIndex++] = y;
+
+        m_pMapped[m_valueIndex++] = r;
+        m_pMapped[m_valueIndex++] = g;
+        m_pMapped[m_valueIndex++] = b;
+        m_pMapped[m_valueIndex++] = a;
+    }
+
+    void addRectangle(float x1, float y1, float x2, float y2, float r, float g, float b, float a) {
+        add(x1, y1, r, g, b, a);
+        add(x2, y1, r, g, b, a);
+        add(x1, y2, r, g, b, a);
+
+        add(x1, y2, r, g, b, a);
+        add(x2, y2, r, g, b, a);
+        add(x2, y1, r, g, b, a);
+    }
+
+    void addRectangleGradient(float x1,
+            float y1,
+            float x2,
+            float y2,
+            float rA,
+            float gA,
+            float bA,
+            float aA,
+            float rB,
+            float gB,
+            float bB,
+            float aB) {
+        add(x1, y1, rA, gA, bA, aA);
+        add(x2, y1, rA, gA, bA, aA);
+        add(x1, y2, rB, gB, bB, aB);
+        add(x1, y2, rB, gB, bB, aB);
+        add(x2, y2, rB, gB, bB, aB);
+        add(x2, y1, rA, gA, bA, aA);
+    }
+};

src/waveform/renderers/allshader/waveformrenderbeat.cpp

@@ -17,6 +17,8 @@ WaveformRenderBeat::WaveformRenderBeat(WaveformWidgetRenderer* waveformWidget)
 void WaveformRenderBeat::initializeGL() {
     WaveformRenderer::initializeGL();
     m_shader.init();
+    m_vertices.create();
+    m_vertices.setUsagePattern(QOpenGLBuffer::DynamicDraw);
 }
 
 void WaveformRenderBeat::setup(const QDomNode& node, const SkinContext& context) {
@@ -81,8 +83,10 @@ void WaveformRenderBeat::paintGL() {
     }
 
     const int reserved = numBeatsInRange * numVerticesPerLine;
-    m_vertices.clear();
+
+    m_vertices.bind();
     m_vertices.reserve(reserved);
+    m_vertices.mapForWrite();
 
     for (auto it = trackBeats->iteratorFrom(startPosition);
             it != trackBeats->cend() && *it <= endPosition;
@@ -101,6 +105,8 @@ void WaveformRenderBeat::paintGL() {
         m_vertices.addRectangle(x1, 0.f, x2, rendererBreadth);
     }
 
+    m_vertices.unmap();
+
     DEBUG_ASSERT(reserved == m_vertices.size());
 
     const int positionLocation = m_shader.positionLocation();
@@ -112,15 +118,19 @@ void WaveformRenderBeat::paintGL() {
 
     const QMatrix4x4 matrix = matrixForWidgetGeometry(m_waveformRenderer, false);
 
-    m_shader.setAttributeArray(
-            positionLocation, GL_FLOAT, m_vertices.constData(), 2);
+    m_shader.setAttributeBuffer(positionLocation,
+            GL_FLOAT,
+            m_vertices.offset(),
+            m_vertices.tupleSize(),
+            m_vertices.stride());
 
     m_shader.setUniformValue(matrixLocation, matrix);
     m_shader.setUniformValue(colorLocation, m_color);
 
     glDrawArrays(GL_TRIANGLES, 0, m_vertices.size());
 
     m_shader.disableAttributeArray(positionLocation);
+    m_vertices.release();
     m_shader.release();
 }
 

src/waveform/renderers/allshader/waveformrenderbeat.h

@@ -4,7 +4,7 @@
 
 #include "shaders/unicolorshader.h"
 #include "util/class.h"
-#include "waveform/renderers/allshader/vertexdata.h"
+#include "waveform/renderers/allshader/vertexbuffer.h"
 #include "waveform/renderers/allshader/waveformrenderer.h"
 
 class QDomNode;
@@ -25,7 +25,7 @@ class allshader::WaveformRenderBeat final : public allshader::WaveformRenderer {
   private:
     mixxx::UnicolorShader m_shader;
     QColor m_color;
-    VertexData m_vertices;
+    Vector2DVertexBuffer m_vertices;
 
     DISALLOW_COPY_AND_ASSIGN(WaveformRenderBeat);
 };

src/waveform/renderers/allshader/waveformrendererfiltered.cpp

@@ -20,6 +20,8 @@ void WaveformRendererFiltered::onSetup(const QDomNode& node) {
 void WaveformRendererFiltered::initializeGL() {
     WaveformRendererSignalBase::initializeGL();
     m_shader.init();
+    m_vertices.create();
+    m_vertices.setUsagePattern(QOpenGLBuffer::DynamicDraw);
 }
 
 void WaveformRendererFiltered::paintGL() {
@@ -72,24 +74,37 @@ void WaveformRendererFiltered::paintGL() {
 
     const int numVerticesPerLine = 6; // 2 triangles
 
+    int startIndex[4];
+    int endIndex[4];
     int reserved[4];
+    int reservedTotal = 0;
     // low, mid, high
     for (int bandIndex = 0; bandIndex < 3; bandIndex++) {
-        m_vertices[bandIndex].clear();
+        startIndex[bandIndex] = reservedTotal;
+        endIndex[bandIndex] = reservedTotal;
         reserved[bandIndex] = numVerticesPerLine * length;
-        m_vertices[bandIndex].reserve(reserved[bandIndex]);
+        reservedTotal += reserved[bandIndex];
+        qDebug() << startIndex[bandIndex] << endIndex[bandIndex]
+                 << reserved[bandIndex] << reservedTotal;
     }
 
     // the horizontal line
+    startIndex[3] = reservedTotal;
+    endIndex[3] = reservedTotal;
     reserved[3] = numVerticesPerLine;
-    m_vertices[3].clear();
-    m_vertices[3].reserve(reserved[3]);
+    reservedTotal += reserved[3];
 
-    m_vertices[3].addRectangle(
+    m_vertices.bind();
+    m_vertices.reserve(reservedTotal);
+    m_vertices.mapForWrite();
+
+    m_vertices.setIndex(endIndex[3]);
+    m_vertices.addRectangle(
             0.f,
             halfBreadth - 0.5f * devicePixelRatio,
             static_cast<float>(length),
             halfBreadth + 0.5f * devicePixelRatio);
+    endIndex[3] += numVerticesPerLine;
 
     const double maxSamplingRange = visualIncrementPerPixel / 2.0;
 
@@ -124,16 +139,20 @@ void WaveformRendererFiltered::paintGL() {
             max[bandIndex][1] *= bandGain[bandIndex];
 
             // lines are thin rectangles
-            m_vertices[bandIndex].addRectangle(
+            m_vertices.setIndex(endIndex[bandIndex]);
+            m_vertices.addRectangle(
                     fpos - 0.5f,
                     halfBreadth - heightFactor * max[bandIndex][0],
                     fpos + 0.5f,
                     halfBreadth + heightFactor * max[bandIndex][1]);
+            endIndex[bandIndex] += numVerticesPerLine;
         }
 
         xVisualFrame += visualIncrementPerPixel;
     }
 
+    m_vertices.unmap();
+
     const QMatrix4x4 matrix = matrixForWidgetGeometry(m_waveformRenderer, true);
 
     const int matrixLocation = m_shader.matrixLocation();
@@ -160,18 +179,25 @@ void WaveformRendererFiltered::paintGL() {
             static_cast<float>(m_axesColor_b),
             static_cast<float>(m_axesColor_a));
 
-    // 3 bands + 1 extra for the horizontal line
+    m_shader.setAttributeBuffer(positionLocation,
+            GL_FLOAT,
+            m_vertices.offset(),
+            m_vertices.tupleSize(),
+            m_vertices.stride());
 
-    for (int i = 0; i < 4; i++) {
-        DEBUG_ASSERT(reserved[i] == m_vertices[i].size());
-        m_shader.setUniformValue(colorLocation, colors[i]);
-        m_shader.setAttributeArray(
-                positionLocation, GL_FLOAT, m_vertices[i].constData(), 2);
+    // 3 bands + 1 extra for the horizontal line
+    for (int bandIndex = 0; bandIndex < 4; bandIndex++) {
+        DEBUG_ASSERT(reserved[bandIndex] == endIndex[bandIndex] - startIndex[bandIndex]);
+        m_shader.setUniformValue(colorLocation, colors[bandIndex]);
 
-        glDrawArrays(GL_TRIANGLES, 0, m_vertices[i].size());
+        glDrawArrays(GL_TRIANGLES,
+                startIndex[bandIndex],
+                endIndex[bandIndex] - startIndex[bandIndex]);
     }
+    DEBUG_ASSERT(reservedTotal == endIndex[3]);
 
     m_shader.disableAttributeArray(positionLocation);
+    m_vertices.release();
     m_shader.release();
 }
 

src/waveform/renderers/allshader/waveformrendererfiltered.h

@@ -2,7 +2,7 @@
 
 #include "shaders/unicolorshader.h"
 #include "util/class.h"
-#include "waveform/renderers/allshader/vertexdata.h"
+#include "waveform/renderers/allshader/vertexbuffer.h"
 #include "waveform/renderers/allshader/waveformrenderersignalbase.h"
 
 namespace allshader {
@@ -21,7 +21,7 @@ class allshader::WaveformRendererFiltered final : public allshader::WaveformRend
 
   private:
     mixxx::UnicolorShader m_shader;
-    VertexData m_vertices[4];
+    Vector2DVertexBuffer m_vertices;
 
     DISALLOW_COPY_AND_ASSIGN(WaveformRendererFiltered);
 };