Use Mesh class in Border effect

Reduced draw calls from 4/8 to 1/2 by specifying 8 vertices accessed via indices to draw each border in a single call.

Author: kblaschke

src/libprojectM/MilkdropPreset/Border.cpp

@@ -4,20 +4,23 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 Border::Border(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
+    , m_borderMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
-    RenderItem::Init();
-}
-
-void Border::InitVertexAttrib()
-{
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
-    glDisableVertexAttribArray(1);
+    m_borderMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Triangles);
+    m_borderMesh.SetVertexCount(8);
 
-    std::array<Point, 4> vertices{};
-    glBufferData(GL_ARRAY_BUFFER, sizeof(Point) * 4, vertices.data(), GL_STREAM_DRAW);
+    m_borderMesh.Indices().Set({
+    {
+        0, 1, 4,
+        1, 4, 5,
+        2, 3, 6,
+        3, 7, 6,
+        2, 0, 6,
+        0, 4, 6,
+        3, 7, 5,
+        1, 3, 5
+    }});
 }
 
 void Border::Draw(const PerFrameContext& presetPerFrameContext)
@@ -26,9 +29,6 @@ void Border::Draw(const PerFrameContext& presetPerFrameContext)
     float const outerBorderSize = static_cast<float>(*presetPerFrameContext.ob_size);
     float const innerBorderSize = static_cast<float>(*presetPerFrameContext.ib_size);
 
-    glBindVertexArray(m_vaoID);
-    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-
     // No additive drawing for borders
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -37,7 +37,8 @@ void Border::Draw(const PerFrameContext& presetPerFrameContext)
     shader->Bind();
     shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
-    std::array<Point, 4> vertices{};
+    m_borderMesh.Bind();
+
     for (int border = 0; border < 2; border++)
     {
         float r = (border == 0) ? static_cast<float>(*presetPerFrameContext.ob_r) : static_cast<float>(*presetPerFrameContext.ib_r);
@@ -52,39 +53,24 @@ void Border::Draw(const PerFrameContext& presetPerFrameContext)
             float innerRadius = (border == 0) ? 1.0f - outerBorderSize : 1.0f - outerBorderSize - innerBorderSize;
             float outerRadius = (border == 0) ? 1.0f : 1.0f - outerBorderSize;
 
-            vertices[0].x = innerRadius;
-            vertices[1].x = outerRadius;
-            vertices[2].x = outerRadius;
-            vertices[3].x = innerRadius;
-            vertices[0].y = innerRadius;
-            vertices[1].y = outerRadius;
-            vertices[2].y = -outerRadius;
-            vertices[3].y = -innerRadius;
-
-            for (int rot = 0; rot < 4; rot++)
-            {
-                glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Point) * 4, vertices.data());
-                glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
-                // Rotate 90 degrees
-                // Milkdrop code calculates cos(PI/2) and sin(PI/2), which is 0 and 1 respectively.
-                // Our code here simplifies the expressions accordingly.
-                for (int vertex = 0; vertex < 4; vertex++)
-                {
-                    float const x = vertices[vertex].x;
-                    float const y = vertices[vertex].y;
-                    vertices[vertex].x = -y; // x * cos(PI/2) - y * sin(PI/2) == x * 0 - y * 1
-                    vertices[vertex].y = x;  // x * sin(PI/2) + y * cos(PI/2) == x * 1 + y * 0
-                }
-            }
+             m_borderMesh.Vertices().Set({{outerRadius, outerRadius},
+                                                     {outerRadius, -outerRadius},
+                                                     {-outerRadius, outerRadius},
+                                                     {-outerRadius, -outerRadius},
+                                                     {innerRadius, innerRadius},
+                                                     {innerRadius, -innerRadius},
+                                                     {-innerRadius, innerRadius},
+                                                     {-innerRadius, -innerRadius}});
+
+            m_borderMesh.Update();
+            m_borderMesh.Draw();
         }
     }
 
+    Renderer::Mesh::Unbind();
     Renderer::Shader::Unbind();
 
     glDisable(GL_BLEND);
-    glBindBuffer(GL_ARRAY_BUFFER, 0);
-    glBindVertexArray(0);
 }
 
 } // namespace MilkdropPreset

src/libprojectM/MilkdropPreset/Border.hpp

@@ -3,7 +3,7 @@
 #include "PerFrameContext.hpp"
 #include "PresetState.hpp"
 
-#include "Renderer/RenderItem.hpp"
+#include <Renderer/Mesh.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -12,15 +12,13 @@ namespace MilkdropPreset {
 /**
  * @brief Renders a border around the screen.
  */
-class Border : public Renderer::RenderItem
+class Border
 {
 public:
     Border() = delete;
 
     explicit Border(PresetState& presetState);
 
-    void InitVertexAttrib() override;
-
     /**
      * Draws the border.
      * @param presetPerFrameContext The per-frame context variables.
@@ -29,6 +27,7 @@ class Border : public Renderer::RenderItem
 
 private:
     PresetState& m_presetState; //!< The global preset state.
+    Renderer::Mesh m_borderMesh; //!< The border geometry.
 };
 
 } // namespace MilkdropPreset