Use Mesh class in Warp effect

kblaschke · kblaschke · commit a85ebc3b2dcf · 2025-10-01T00:21:09.000+02:00
Now using the generated grid vertices and indices directly, drawing the warp mesh in a single draw call. This will increase the number of drawn vertices, but all GPUs made in the past decade can easily deal with 100K triangles or more.
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
@@ -18,44 +18,31 @@
 namespace libprojectM {
 namespace MilkdropPreset {
 
-static constexpr uint32_t VerticesPerDrawCall = 1024 * 3;
-
 PerPixelMesh::PerPixelMesh()
-    : RenderItem()
-{
-    RenderItem::Init();
-}
-
-void PerPixelMesh::InitVertexAttrib()
+    : m_warpMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
-    m_drawVertices.resize(VerticesPerDrawCall); // Fixed size, may scale it later depending on GPU caps.
-
-    glGenVertexArrays(1, &m_vaoID);
-    glGenBuffers(1, &m_vboID);
-
-    glBindVertexArray(m_vaoID);
-    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-
-    glEnableVertexAttribArray(0);
-    glEnableVertexAttribArray(1);
-    glEnableVertexAttribArray(2);
-    glEnableVertexAttribArray(3);
-    glEnableVertexAttribArray(4);
-    glEnableVertexAttribArray(5);
-
-    // Only position & texture coordinates are per-vertex, colors are equal all over the grid (used for decay).
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), reinterpret_cast<void*>(offsetof(MeshVertex, x)));         // Position, radius & angle
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), reinterpret_cast<void*>(offsetof(MeshVertex, radius)));    // Position, radius & angle
-    glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), reinterpret_cast<void*>(offsetof(MeshVertex, zoom)));      // zoom, zoom exponent, rotation & warp
-    glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), reinterpret_cast<void*>(offsetof(MeshVertex, centerX)));   // Center coord
-    glVertexAttribPointer(4, 2, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), reinterpret_cast<void*>(offsetof(MeshVertex, distanceX))); // Distance
-    glVertexAttribPointer(5, 2, GL_FLOAT, GL_FALSE, sizeof(MeshVertex), reinterpret_cast<void*>(offsetof(MeshVertex, stretchX)));  // Stretch
-
-    // Pre-allocate vertex buffer
-    glBufferData(GL_ARRAY_BUFFER, sizeof(MeshVertex) * m_drawVertices.size(), m_drawVertices.data(), GL_STREAM_DRAW);
-
-    glBindVertexArray(0);
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    m_warpMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Triangles);
+
+    m_warpMesh.Bind();
+    m_radiusAngleBuffer.Bind();
+    m_zoomRotWarpBuffer.Bind();
+    m_centerBuffer.Bind();
+    m_distanceBuffer.Bind();
+    m_stretchBuffer.Bind();
+
+    m_radiusAngleBuffer.InitializeAttributePointer(3);
+    m_zoomRotWarpBuffer.InitializeAttributePointer(4);
+    m_centerBuffer.InitializeAttributePointer(5);
+    m_distanceBuffer.InitializeAttributePointer(6);
+    m_stretchBuffer.InitializeAttributePointer(7);
+
+    Renderer::VertexBuffer<Renderer::Point>::SetEnableAttributeArray(3, true);
+    Renderer::VertexBuffer<Renderer::Point>::SetEnableAttributeArray(4, true);
+    Renderer::VertexBuffer<Renderer::Point>::SetEnableAttributeArray(5, true);
+    Renderer::VertexBuffer<Renderer::Point>::SetEnableAttributeArray(6, true);
+    Renderer::VertexBuffer<Renderer::Point>::SetEnableAttributeArray(7, true);
+
+    Renderer::Mesh::Unbind();
 }
 
 void PerPixelMesh::LoadWarpShader(const PresetState& presetState)
@@ -139,9 +126,17 @@ void PerPixelMesh::InitializeMesh(const PresetState& presetState)
         m_gridSizeX = presetState.renderContext.perPixelMeshX;
         m_gridSizeY = presetState.renderContext.perPixelMeshY;
 
-        // Grid size has changed, reallocate vertex buffers
-        m_vertices.resize((m_gridSizeX + 1) * (m_gridSizeY + 1));
-        m_listIndices.resize(m_gridSizeX * m_gridSizeY * 6);
+        // Grid size has changed, resize buffers accordingly
+        const size_t vertexCount = (m_gridSizeX + 1) * (m_gridSizeY + 1);
+
+        m_warpMesh.SetVertexCount(vertexCount);
+        m_radiusAngleBuffer.Resize(vertexCount);
+        m_zoomRotWarpBuffer.Resize(vertexCount);
+        m_centerBuffer.Resize(vertexCount);
+        m_distanceBuffer.Resize(vertexCount);
+        m_stretchBuffer.Resize(vertexCount);
+
+        m_warpMesh.Indices().Resize(m_gridSizeX * m_gridSizeY * 6);
     }
     else if (m_viewportWidth == presetState.renderContext.viewportSizeX &&
              m_viewportHeight == presetState.renderContext.viewportSizeY)
@@ -150,29 +145,29 @@ void PerPixelMesh::InitializeMesh(const PresetState& presetState)
         return;
     }
 
-    float aspectX = static_cast<float>(presetState.renderContext.aspectX);
-    float aspectY = static_cast<float>(presetState.renderContext.aspectY);
+    const float aspectX = presetState.renderContext.aspectX;
+    const float aspectY = presetState.renderContext.aspectY;
 
     // Either viewport size or mesh size changed, reinitialize the vertices.
+    auto& vertices = m_warpMesh.Vertices();
     int vertexIndex{0};
     for (int gridY = 0; gridY <= m_gridSizeY; gridY++)
     {
         for (int gridX = 0; gridX <= m_gridSizeX; gridX++)
         {
-            auto& vertex = m_vertices.at(vertexIndex);
-
-            vertex.x = static_cast<float>(gridX) / static_cast<float>(m_gridSizeX) * 2.0f - 1.0f;
-            vertex.y = static_cast<float>(gridY) / static_cast<float>(m_gridSizeY) * 2.0f - 1.0f;
+            const float x = static_cast<float>(gridX) / static_cast<float>(m_gridSizeX) * 2.0f - 1.0f;
+            const float y = static_cast<float>(gridY) / static_cast<float>(m_gridSizeY) * 2.0f - 1.0f;
+            vertices[vertexIndex] = {x, y};
 
             // Milkdrop uses sqrtf, but hypotf is probably safer.
-            vertex.radius = hypotf(vertex.x * aspectX, vertex.y * aspectY);
+            m_radiusAngleBuffer[vertexIndex].radius = hypotf(x * aspectX, y * aspectY);
             if (gridY == m_gridSizeY / 2 && gridX == m_gridSizeX / 2)
             {
-                vertex.angle = 0.0f;
+                m_radiusAngleBuffer[vertexIndex].angle = 0.0f;
             }
             else
             {
-                vertex.angle = atan2f(vertex.y * aspectY, vertex.x * aspectX);
+                m_radiusAngleBuffer[vertexIndex].angle = atan2f(y * aspectY, x * aspectX);
             }
 
             vertexIndex++;
@@ -204,12 +199,12 @@ void PerPixelMesh::InitializeMesh(const PresetState& presetState)
                 // 0 - 1      3
                 //   /      /
                 // 2      4 - 5
-                m_listIndices.at(vertexListIndex++) = vertex;
-                m_listIndices.at(vertexListIndex++) = vertex + 1;
-                m_listIndices.at(vertexListIndex++) = vertex + m_gridSizeX + 1;
-                m_listIndices.at(vertexListIndex++) = vertex + 1;
-                m_listIndices.at(vertexListIndex++) = vertex + m_gridSizeX + 1;
-                m_listIndices.at(vertexListIndex++) = vertex + m_gridSizeX + 2;
+                m_warpMesh.Indices()[vertexListIndex++] = vertex;
+                m_warpMesh.Indices()[vertexListIndex++] = vertex + 1;
+                m_warpMesh.Indices()[vertexListIndex++] = vertex + m_gridSizeX + 1;
+                m_warpMesh.Indices()[vertexListIndex++] = vertex + 1;
+                m_warpMesh.Indices()[vertexListIndex++] = vertex + m_gridSizeX + 1;
+                m_warpMesh.Indices()[vertexListIndex++] = vertex + m_gridSizeX + 2;
             }
         }
     }
@@ -232,19 +227,25 @@ void PerPixelMesh::CalculateMesh(const PresetState& presetState, const PerFrameC
     int vertex = 0;
 
     // Can't make this multithreaded as per-pixel code may use gmegabuf or regXX vars.
+    auto& vertices = m_warpMesh.Vertices();
     for (int y = 0; y <= m_gridSizeY; y++)
     {
         for (int x = 0; x <= m_gridSizeX; x++)
         {
-            auto& curVertex = m_vertices[vertex];
+            auto& curVertex = vertices[vertex];
+            auto& curRadiusAngle = m_radiusAngleBuffer[vertex];
+            auto& curZoomRotWarp = m_zoomRotWarpBuffer[vertex];
+            auto& curCenter = m_centerBuffer[vertex];
+            auto& curDistance = m_distanceBuffer[vertex];
+            auto& curStretch = m_stretchBuffer[vertex];
 
             // Execute per-vertex/per-pixel code if the preset uses it.
             if (perPixelContext.perPixelCodeHandle)
             {
-                *perPixelContext.x = static_cast<double>(curVertex.x * 0.5f * presetState.renderContext.aspectX + 0.5f);
-                *perPixelContext.y = static_cast<double>(curVertex.y * -0.5f * presetState.renderContext.aspectY + 0.5f);
-                *perPixelContext.rad = static_cast<double>(curVertex.radius);
-                *perPixelContext.ang = static_cast<double>(curVertex.angle);
+                *perPixelContext.x = static_cast<double>(curVertex.X() * 0.5f * presetState.renderContext.aspectX + 0.5f);
+                *perPixelContext.y = static_cast<double>(curVertex.Y() * -0.5f * presetState.renderContext.aspectY + 0.5f);
+                *perPixelContext.rad = static_cast<double>(curRadiusAngle.radius);
+                *perPixelContext.ang = static_cast<double>(curRadiusAngle.angle);
                 *perPixelContext.zoom = static_cast<double>(*perFrameContext.zoom);
                 *perPixelContext.zoomexp = static_cast<double>(*perFrameContext.zoomexp);
                 *perPixelContext.rot = static_cast<double>(*perFrameContext.rot);
@@ -258,34 +259,38 @@ void PerPixelMesh::CalculateMesh(const PresetState& presetState, const PerFrameC
 
                 perPixelContext.ExecutePerPixelCode();
 
-                curVertex.zoom = static_cast<float>(*perPixelContext.zoom);
-                curVertex.zoomExp = static_cast<float>(*perPixelContext.zoomexp);
-                curVertex.rot = static_cast<float>(*perPixelContext.rot);
-                curVertex.warp = static_cast<float>(*perPixelContext.warp);
-                curVertex.centerX = static_cast<float>(*perPixelContext.cx);
-                curVertex.centerY = static_cast<float>(*perPixelContext.cy);
-                curVertex.distanceX = static_cast<float>(*perPixelContext.dx);
-                curVertex.distanceY = static_cast<float>(*perPixelContext.dy);
-                curVertex.stretchX = static_cast<float>(*perPixelContext.sx);
-                curVertex.stretchY = static_cast<float>(*perPixelContext.sy);
+                curZoomRotWarp.zoom = static_cast<float>(*perPixelContext.zoom);
+                curZoomRotWarp.zoomExp = static_cast<float>(*perPixelContext.zoomexp);
+                curZoomRotWarp.rot = static_cast<float>(*perPixelContext.rot);
+                curZoomRotWarp.warp = static_cast<float>(*perPixelContext.warp);
+                curCenter = {static_cast<float>(*perPixelContext.cx),
+                             static_cast<float>(*perPixelContext.cy)};
+                curDistance = {static_cast<float>(*perPixelContext.dx),
+                               static_cast<float>(*perPixelContext.dy)};
+                curStretch = {static_cast<float>(*perPixelContext.sx),
+                              static_cast<float>(*perPixelContext.sy)};
             }
             else
             {
-                curVertex.zoom = zoom;
-                curVertex.zoomExp = zoomExp;
-                curVertex.rot = rot;
-                curVertex.warp = warp;
-                curVertex.centerX = cx;
-                curVertex.centerY = cy;
-                curVertex.distanceX = dx;
-                curVertex.distanceY = dy;
-                curVertex.stretchX = sx;
-                curVertex.stretchY = sy;
+                curZoomRotWarp.zoom = zoom;
+                curZoomRotWarp.zoomExp = zoomExp;
+                curZoomRotWarp.rot = rot;
+                curZoomRotWarp.warp = warp;
+                curCenter = { cx, cy};
+                curDistance = {dx, dy};
+                curStretch = {sx, sy};
             }
 
             vertex++;
         }
     }
+
+    m_warpMesh.Update();
+    m_radiusAngleBuffer.Update();
+    m_zoomRotWarpBuffer.Update();
+    m_centerBuffer.Update();
+    m_distanceBuffer.Update();
+    m_stretchBuffer.Update();
 }
 
 void PerPixelMesh::WarpedBlit(const PresetState& presetState,
@@ -362,38 +367,9 @@ void PerPixelMesh::WarpedBlit(const PresetState& presetState,
     }
     m_perPixelSampler.Bind(0);
 
-    glBindVertexArray(m_vaoID);
-    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-
-    int trianglesPerBatch = static_cast<int>(m_drawVertices.size() / 3 - 4);
-    int triangleCount = m_gridSizeX * m_gridSizeY * 2; // Two triangles per quad/grid cell.
-    int sourceIndex = 0;
-
-    while (sourceIndex < triangleCount * 3)
-    {
-        int trianglesQueued = 0;
-        int vertex = 0;
-        while (trianglesQueued < trianglesPerBatch && sourceIndex < triangleCount * 3)
-        {
-            // Copy one triangle/3 vertices
-            for (int i = 0; i < 3; i++)
-            {
-                m_drawVertices[vertex++] = m_vertices[m_listIndices[sourceIndex++]];
-            }
-
-            trianglesQueued++;
-        }
-
-        if (trianglesQueued > 0)
-        {
-            glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(MeshVertex) * trianglesQueued * 3, m_drawVertices.data());
-            glDrawArrays(GL_TRIANGLES, 0, trianglesQueued * 3);
-        }
-    }
-
-    glBindVertexArray(0);
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    m_warpMesh.Draw();
 
+    Renderer::Mesh::Unbind();
     Renderer::Sampler::Unbind(0);
     Renderer::Shader::Unbind();
 }
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
@@ -1,10 +1,8 @@
 #pragma once
 
-#include <Renderer/RenderItem.hpp>
-#include <Renderer/Shader.hpp>
+#include "Renderer/Mesh.hpp"
 
-#include <cstdint>
-#include <vector>
+#include <Renderer/Shader.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -27,13 +25,11 @@ class MilkdropShader;
  *
  * The mesh size can be changed between frames, the class will reallocate the buffers if needed.
  */
-class PerPixelMesh : public Renderer::RenderItem
+class PerPixelMesh
 {
 public:
     PerPixelMesh();
 
-    void InitVertexAttrib() override;
-
     /**
      * @brief Loads the warp shader, if the preset uses one.
      * @param presetState The preset state to retrieve the shader from.
@@ -59,31 +55,33 @@ class PerPixelMesh : public Renderer::RenderItem
 
 private:
     /**
-     * Warp mesh vertex with all required attributes.
+     * Vertex attributes for radius and angle.
      */
-    struct MeshVertex {
-        float x{};
-        float y{};
+    struct RadiusAngle {
         float radius{};
         float angle{};
 
+        static void InitializeAttributePointer(uint32_t attributeIndex)
+        {
+            glVertexAttribPointer(attributeIndex, sizeof(RadiusAngle) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(RadiusAngle), nullptr);
+        }
+    };
+
+    /**
+     * Vertex attributes for zoom, zoom exponent, rotation and warp strength.
+     */
+    struct ZoomRotWarp {
         float zoom{};
         float zoomExp{};
         float rot{};
         float warp{};
 
-        float centerX{};
-        float centerY{};
-
-        float distanceX{};
-        float distanceY{};
-
-        float stretchX{};
-        float stretchY{};
+        static void InitializeAttributePointer(uint32_t attributeIndex)
+        {
+            glVertexAttribPointer(attributeIndex, sizeof(ZoomRotWarp) / sizeof(float), GL_FLOAT, GL_FALSE, sizeof(ZoomRotWarp), nullptr);
+        }
     };
 
-    using VertexList = std::vector<MeshVertex>;
-
     /**
      * @brief Initializes the vertex array and fills in static data if needed.
      *
@@ -124,10 +122,12 @@ class PerPixelMesh : public Renderer::RenderItem
     int m_viewportWidth{};  //!< Last known viewport width.
     int m_viewportHeight{}; //!< Last known viewport height.
 
-    VertexList m_vertices; //!< The calculated mesh vertices.
-
-    std::vector<int> m_listIndices; //!< List of vertex indices to render.
-    VertexList m_drawVertices;      //!< Temp data buffer for the vertices to be drawn.
+    Renderer::Mesh m_warpMesh;                                //!< The Warp effect mesh
+    Renderer::VertexBuffer<RadiusAngle> m_radiusAngleBuffer;  //!< Vertex attribute buffer for radius and angle values.
+    Renderer::VertexBuffer<ZoomRotWarp> m_zoomRotWarpBuffer;  //!< Vertex attribute buffer for zoom, roation and warp values.
+    Renderer::VertexBuffer<Renderer::Point> m_centerBuffer;   //!< Vertex attribute buffer for center coordinate values.
+    Renderer::VertexBuffer<Renderer::Point> m_distanceBuffer; //!< Vertex attribute buffer for distance values.
+    Renderer::VertexBuffer<Renderer::Point> m_stretchBuffer;  //!< Vertex attribute buffer for stretch values.
 
     std::weak_ptr<Renderer::Shader> m_perPixelMeshShader;             //!< Special shader which calculates the per-pixel UV coordinates.
     std::unique_ptr<MilkdropShader> m_warpShader;                     //!< The warp shader. Either preset-defined or a default shader.
diff --git a/src/libprojectM/MilkdropPreset/Shaders/PresetWarpVertexShaderGlsl330.vert b/src/libprojectM/MilkdropPreset/Shaders/PresetWarpVertexShaderGlsl330.vert
@@ -14,11 +14,11 @@ precision mediump float;
 #define invAspectY aspect.w
 
 layout(location = 0) in vec2 vertex_position;
-layout(location = 1) in vec2 rad_ang;
-layout(location = 2) in vec4 transforms;
-layout(location = 3) in vec2 warp_center;
-layout(location = 4) in vec2 warp_distance;
-layout(location = 5) in vec2 stretch;
+layout(location = 3) in vec2 rad_ang;
+layout(location = 4) in vec4 transforms;
+layout(location = 5) in vec2 warp_center;
+layout(location = 6) in vec2 warp_distance;
+layout(location = 7) in vec2 stretch;
 
 uniform mat4 vertex_transformation;
 uniform vec4 aspect;
