Use Mesh class in Motion Vector effect

Also get rid of the additional index attribute array, as gl_VertexID contains the same information and is free.

Author: kblaschke

src/libprojectM/MilkdropPreset/MotionVectors.cpp

@@ -5,24 +5,16 @@
 #include <Renderer/ShaderCache.hpp>
 #include <Renderer/TextureManager.hpp>
 
+#include <algorithm>
+
 namespace libprojectM {
 namespace MilkdropPreset {
 
 MotionVectors::MotionVectors(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
+    , m_motionVectorMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
-    RenderItem::Init();
-}
-
-void MotionVectors::InitVertexAttrib()
-{
-    glEnableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
-    glEnableVertexAttribArray(2);
-
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(MotionVectorVertex), reinterpret_cast<void*>(offsetof(MotionVectorVertex, x)));
-    glVertexAttribIPointer(2, 1, GL_INT, sizeof(MotionVectorVertex), reinterpret_cast<void*>(offsetof(MotionVectorVertex, index)));
+    m_motionVectorMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Lines);
 }
 
 void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture)
@@ -59,30 +51,16 @@ void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shar
     auto const divertY2 = static_cast<float>(*presetPerFrameContext.mv_dy);
 
     // Clamp X/Y diversions to 0..1
-    if (divertX < 0.0f)
-    {
-        divertX = 0.0f;
-    }
-    if (divertX > 1.0f)
-    {
-        divertX = 1.0f;
-    }
-    if (divertY < 0.0f)
-    {
-        divertY = 0.0f;
-    }
-    if (divertY > 1.0f)
-    {
-        divertY = 1.0f;
-    }
+    divertX = std::min(1.0f, std::max(0.0f, divertX));
+    divertY = std::min(1.0f, std::max(0.0f, divertY));
 
     // Tweaked this a bit to ensure lines are always at least a bit more than 1px long.
     // Line smoothing makes some of them disappear otherwise.
     float const inverseWidth = 1.25f / static_cast<float>(m_presetState.renderContext.viewportSizeX);
     float const inverseHeight = 1.25f / static_cast<float>(m_presetState.renderContext.viewportSizeY);
     float const minimumLength = sqrtf(inverseWidth * inverseWidth + inverseHeight * inverseHeight);
 
-    std::vector<MotionVectorVertex> lineVertices(static_cast<std::size_t>(countX + 1) * 2); // countX + 1 lines for each grid row, 2 vertices each.
+    m_motionVectorMesh.SetVertexCount(static_cast<std::size_t>(countX + 1) * 2); // countX + 1 lines for each grid row, 2 vertices each.
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -103,14 +81,13 @@ void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shar
                      static_cast<float>(*presetPerFrameContext.mv_b),
                      static_cast<float>(*presetPerFrameContext.mv_a));
 
-    glBindVertexArray(m_vaoID);
-    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-
     glLineWidth(1);
 #ifndef USE_GLES
     glEnable(GL_LINE_SMOOTH);
 #endif
 
+    auto& lineVertices = m_motionVectorMesh.Vertices();
+
     for (int y = 0; y < countY; y++)
     {
         float const posY = (static_cast<float>(y) + 0.25f) / (static_cast<float>(countY) + divertY + 0.25f - 1.0f) - divertY2;
@@ -124,40 +101,25 @@ void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shar
 
                 if (posX > 0.0001f && posX < 0.9999f)
                 {
-                    lineVertices[vertex].x = posX;
-                    lineVertices[vertex].y = posY;
-                    lineVertices[vertex].index = vertex;
-
-                    lineVertices[vertex + 1] = lineVertices[vertex];
-                    lineVertices[vertex + 1].index++;
+                    lineVertices[vertex + 1] = lineVertices[vertex] = {posX, posY};
 
                     vertex += 2;
                 }
             }
 
             // Draw a row of lines.
-            if (m_lastVertexCount >= vertex)
-            {
-                glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(MotionVectorVertex) * vertex, lineVertices.data());
-            }
-            else
-            {
-                glBufferData(GL_ARRAY_BUFFER, sizeof(MotionVectorVertex) * vertex, lineVertices.data(), GL_STREAM_DRAW);
-                m_lastVertexCount = vertex;
-            }
-            glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(vertex));
+            m_motionVectorMesh.Update();
+            m_motionVectorMesh.Draw();
         }
     }
 
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    glBindVertexArray(0);
+    Renderer::Mesh::Unbind();
+    Renderer::Shader::Unbind();
 
 #ifndef USE_GLES
     glDisable(GL_LINE_SMOOTH);
 #endif
 
-    Renderer::Shader::Unbind();
-
     glDisable(GL_BLEND);
 }
 

src/libprojectM/MilkdropPreset/MotionVectors.hpp

@@ -3,7 +3,7 @@
 #include "PerFrameContext.hpp"
 #include "PresetState.hpp"
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Mesh.hpp>
 
 #include <memory>
 
@@ -13,21 +13,18 @@ namespace MilkdropPreset {
 /**
  * @brief Draws a flexible motion vector field.
  *
- * This is broken right now, as it only renders a relatively static 1px point grid, with no apparent motion trails.
- * Milkdrop renders this as lines with trails.
- *
- * @todo Reverse-engineer the original Milkdrop code and reimplement it properly.
- *       https://github.com/projectM-visualizer/milkdrop2/blob/f05b0d811a87a17c4624170c26c93bac39b05bde/src/vis_milk2/milkdropfs.cpp#L1239
+ * Uses the same drawing logic as Milkdrop, but instead of reverse-propagating the motion data
+ * on the CPU, projectM does this within the Motion Vector vertex shader. The Warp effect draws the
+ * final U/V coordinates to a float texture, which is then used in the next frame to calculate the
+ * vector length at the location of the line origin.
  */
-class MotionVectors : public Renderer::RenderItem
+class MotionVectors
 {
 public:
     MotionVectors() = delete;
 
     explicit MotionVectors(PresetState& presetState);
 
-    void InitVertexAttrib();
-
     /**
      * Renders the motion vectors.
      * @param presetPerFrameContext The per-frame context variables.
@@ -36,20 +33,14 @@ class MotionVectors : public Renderer::RenderItem
     void Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture);
 
 private:
-    struct MotionVectorVertex {
-        float x{};
-        float y{};
-        int32_t index{};
-    };
-
     std::shared_ptr<Renderer::Shader> GetShader();
 
     PresetState& m_presetState; //!< The global preset state.
 
+    Renderer::Mesh m_motionVectorMesh; //!< The Motion Vector geometry.
+
     std::weak_ptr<Renderer::Shader> m_motionVectorShader;                                                           //!< The motion vector shader, calculates the trace positions in the GPU.
     std::shared_ptr<Renderer::Sampler> m_sampler{std::make_shared<Renderer::Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR)}; //!< The texture sampler.
-
-    int m_lastVertexCount{}; //!< Number of vertices drawn in the previous draw call.
 };
 
 } // namespace MilkdropPreset

src/libprojectM/MilkdropPreset/Shaders/PresetMotionVectorsVertexShaderGlsl330.vert

@@ -2,7 +2,6 @@ precision mediump float;
 
 layout(location = 0) in vec2 vertex_position;
 layout(location = 1) in vec4 vertex_color;
-layout(location = 2) in int vertex_index;
 
 uniform mat4 vertex_transformation;
 uniform float length_multiplier;
@@ -17,7 +16,7 @@ void main() {
     // screen coordinates.
     vec2 pos = vertex_position;
 
-    if (vertex_index % 2 == 1)
+    if (gl_VertexID % 2 == 1)
     {
         // Reverse propagation using the u/v texture written in the previous frame.
         // Milkdrop's original code did a simple bilinear interpolation, but here it was already