Use Mesh class in User Sprites

kblaschke · kblaschke · commit 2d5a365e70a5 · 2025-10-01T00:30:40.000+02:00
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.cpp b/src/libprojectM/UserSprites/MilkdropSprite.cpp
@@ -1,5 +1,6 @@
 #include "UserSprites/MilkdropSprite.hpp"
 
+#include "SpriteException.hpp"
 #include "SpriteShaders.hpp"
 
 #include <Preset.hpp>
@@ -24,19 +25,9 @@ namespace libprojectM {
 namespace UserSprites {
 
 MilkdropSprite::MilkdropSprite()
+    : m_mesh(Renderer::VertexBufferUsage::DynamicDraw, false, true)
 {
-    RenderItem::Init();
-}
-
-void MilkdropSprite::InitVertexAttrib()
-{
-    glEnableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
-    glEnableVertexAttribArray(2);
-
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position
-    // Color (index 1) is passed as a 4-float constant vertex attribute.
-    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, u))); // Texture coordinate
+    m_mesh.SetVertexCount(4);
 }
 
 void MilkdropSprite::Init(const std::string& spriteData, const Renderer::RenderContext& renderContext)
@@ -119,7 +110,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
     m_spriteDone = *m_codeContext.done != 0.0;
     bool burnIn = *m_codeContext.burn != 0.0;
 
-    Quad vertices{};
+    auto& vertices = m_mesh.Vertices().Get();
 
     // Get values from expression code and clamp them where necessary.
     float x = std::min(1000.0f, std::max(-1000.0f, static_cast<float>(*m_codeContext.x) * 2.0f - 1.0f));
@@ -139,14 +130,14 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
     float a = std::min(1.0f, std::max(0.0f, (static_cast<float>(*m_codeContext.a))));
 
     // ToDo: Move all translations to vertex shader
-    vertices[0 + flipx].x = -sx;
-    vertices[1 - flipx].x = sx;
-    vertices[2 + flipx].x = -sx;
-    vertices[3 - flipx].x = sx;
-    vertices[0 + flipy * 2].y = -sy;
-    vertices[1 + flipy * 2].y = -sy;
-    vertices[2 - flipy * 2].y = sy;
-    vertices[3 - flipy * 2].y = sy;
+    vertices[0 + flipx].SetX(-sx);
+    vertices[1 - flipx].SetX(sx);
+    vertices[2 + flipx].SetX(-sx);
+    vertices[3 - flipx].SetX(sx);
+    vertices[0 + flipy * 2].SetY(-sy);
+    vertices[1 + flipy * 2].SetY(-sy);
+    vertices[2 - flipy * 2].SetY(sy);
+    vertices[3 - flipy * 2].SetY(sy);
 
     // First aspect ratio: adjust for non-1:1 images
     {
@@ -157,15 +148,15 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
             // Landscape image
             for (auto& vertex : vertices)
             {
-                vertex.y *= aspect;
+                vertex.SetY(vertex.Y() * aspect);
             }
         }
         else
         {
             // Portrait image
             for (auto& vertex : vertices)
             {
-                vertex.x /= aspect;
+                vertex.SetX(vertex.X() / aspect);
             }
         }
     }
@@ -177,18 +168,17 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
 
         for (auto& vertex : vertices)
         {
-            float rotX = vertex.x * cos_rot - vertex.y * sin_rot;
-            float rotY = vertex.x * sin_rot + vertex.y * cos_rot;
-            vertex.x = rotX;
-            vertex.y = rotY;
+            float rotX = vertex.X() * cos_rot - vertex.Y() * sin_rot;
+            float rotY = vertex.X() * sin_rot + vertex.Y() * cos_rot;
+            vertex = {rotX, rotY};
         }
     }
 
     // Translation
     for (auto& vertex : vertices)
     {
-        vertex.x += x;
-        vertex.y += y;
+        vertex.SetX(vertex.X() + x);
+        vertex.SetY(vertex.Y() + y);
     }
 
     // Second aspect ratio: normalize to width of screen
@@ -199,14 +189,14 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
         {
             for (auto& vertex : vertices)
             {
-                vertex.y *= aspect;
+                vertex.SetY(vertex.Y() * aspect);
             }
         }
         else
         {
             for (auto& vertex : vertices)
             {
-                vertex.x /= aspect;
+                vertex.SetX(vertex.X() / aspect);
             }
         }
     }
@@ -219,19 +209,15 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
         float dtu = 0.5f;
         float dtv = 0.5f;
 
-        vertices[0].u = -dtu;
-        vertices[1].u = dtu;
-        vertices[2].u = -dtu;
-        vertices[3].u = dtu;
-        vertices[0].v = -dtv;
-        vertices[1].v = -dtv;
-        vertices[2].v = dtv;
-        vertices[3].v = dtv;
+        m_mesh.UVs().Set({{-dtu, -dtv},
+                          {dtu, -dtv},
+                          {-dtu, dtv},
+                          {dtu, dtv}});
 
-        for (auto& vertex : vertices)
+        for (auto& uv : m_mesh.UVs().Get())
         {
-            vertex.u = (vertex.u - 0.0f) * repeatx + 0.5f;
-            vertex.v = (vertex.v - 0.0f) * repeaty + 0.5f;
+            uv = {(uv.U() - 0.0f) * repeatx + 0.5f,
+                  (uv.V() - 0.0f) * repeaty + 0.5f};
         }
     }
 
@@ -243,9 +229,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
     m_texture->Bind(0);
     m_sampler.Bind(0);
 
-    glBindVertexArray(m_vaoID);
-    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_DYNAMIC_DRAW);
+    m_mesh.Update();
 
     glVertexAttrib4f(1, r, g, b, a);
 
@@ -275,7 +259,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
     }
 
     // Draw to current output buffer
-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    m_mesh.Draw();
 
     if (burnIn)
     {
@@ -288,7 +272,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
             }
 
             preset.get()->BindFramebuffer();
-            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+            m_mesh.Draw();
         }
 
         // Reset to original FBO
@@ -300,6 +284,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
     m_texture->Unbind(0);
+    Renderer::Mesh::Unbind();
     Renderer::Shader::Unbind();
 }
 
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.hpp b/src/libprojectM/UserSprites/MilkdropSprite.hpp
@@ -2,6 +2,7 @@
 
 #include "UserSprites/Sprite.hpp"
 
+#include <Renderer/Mesh.hpp>
 #include <Renderer/Texture.hpp>
 #include <Renderer/TextureSamplerDescriptor.hpp>
 
@@ -17,25 +18,20 @@ class MilkdropSprite : public Sprite
 
     ~MilkdropSprite() override = default;
 
-    void InitVertexAttrib() override;
-
     void Init(const std::string& spriteData, const Renderer::RenderContext& renderContext) override;
 
     void Draw(const Audio::FrameAudioData& audioData,
               const Renderer::RenderContext& renderContext,
               uint32_t outputFramebufferObject,
               PresetList presets) override;
 
-    auto Done() const-> bool override;
+    auto Done() const -> bool override;
 
 private:
-    using Quad = std::array<TexturedPoint, 4>;
-
     /**
      * @brief Context for the init and per-frame code.
      */
-    struct CodeContext
-    {
+    struct CodeContext {
         CodeContext();
 
         ~CodeContext();
@@ -61,46 +57,45 @@ class MilkdropSprite : public Sprite
                              const Renderer::RenderContext& renderContext);
 
         projectm_eval_context* spriteCodeContext{nullptr}; //!< The code runtime context, holds memory buffers and variables.
-        projectm_eval_code* perFrameCodeHandle{nullptr};     //!< The compiled per-frame code handle.
+        projectm_eval_code* perFrameCodeHandle{nullptr};   //!< The compiled per-frame code handle.
 
         // Input variables
-        PRJM_EVAL_F* time{}; //!< Time passed since program start. Also available in init code.
-        PRJM_EVAL_F* frame{}; //!< Total frames rendered so far. Also available in init code.
-        PRJM_EVAL_F* fps{}; //!< Current (or, if not available, target) frames per second value.
+        PRJM_EVAL_F* time{};     //!< Time passed since program start. Also available in init code.
+        PRJM_EVAL_F* frame{};    //!< Total frames rendered so far. Also available in init code.
+        PRJM_EVAL_F* fps{};      //!< Current (or, if not available, target) frames per second value.
         PRJM_EVAL_F* progress{}; //!< Preset blending progress (only if blending).
-        PRJM_EVAL_F* bass{}; //!< Bass frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
-        PRJM_EVAL_F* mid{}; //!< Middle frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
-        PRJM_EVAL_F* treb{}; //!< Treble frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
+        PRJM_EVAL_F* bass{};     //!< Bass frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
+        PRJM_EVAL_F* mid{};      //!< Middle frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
+        PRJM_EVAL_F* treb{};     //!< Treble frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
         PRJM_EVAL_F* bass_att{}; //!< More attenuated/smoothed value of bass.
-        PRJM_EVAL_F* mid_att{}; //!< More attenuated/smoothed value of mid.
+        PRJM_EVAL_F* mid_att{};  //!< More attenuated/smoothed value of mid.
         PRJM_EVAL_F* treb_att{}; //!< More attenuated/smoothed value of treb.
 
         // Output variables
-        PRJM_EVAL_F* done{}; //!< If this becomes non-zero, the sprite is deleted. Default: 0.0
-        PRJM_EVAL_F* burn{}; //!< If non-zero, the sprite will be "burned" into currently rendered presets when done is also true, effectively "dissolving" the sprite in the preset. Default: 1.0
-        PRJM_EVAL_F* x{}; //!< Sprite x position (position of the image center). Range from -1000 to 1000. Default: 0.5
-        PRJM_EVAL_F* y{}; //!< Sprite y position (position of the image center). Range from -1000 to 1000. Default: 0.5
-        PRJM_EVAL_F* sx{}; //!< Sprite x scaling factor. Range from -1000 to 1000. Default: 1.0
-        PRJM_EVAL_F* sy{}; //!< Sprite y scaling factor. Range from -1000 to 1000. Default: 1.0
-        PRJM_EVAL_F* rot{}; //!< Sprite rotation in radians (2*PI equals one full rotation). Default: 0.0
-        PRJM_EVAL_F* flipx{}; //!< If flag is non-zero, the sprite is flipped on the x axis. Default: 0.0
-        PRJM_EVAL_F* flipy{}; //!< If flag is non-zero, the sprite is flipped on the y axis. Default: 0.0
-        PRJM_EVAL_F* repeatx{}; //!< Repeat count of the image on the sprite quad on the x axis. Fractional values allowed. Range from 0.01 to 100.0. Default: 1.0
-        PRJM_EVAL_F* repeaty{}; //!< Repeat count of the image on the sprite quad on the y axis. Fractional values allowed. Range from 0.01 to 100.0. Default: 1.0
+        PRJM_EVAL_F* done{};      //!< If this becomes non-zero, the sprite is deleted. Default: 0.0
+        PRJM_EVAL_F* burn{};      //!< If non-zero, the sprite will be "burned" into currently rendered presets when done is also true, effectively "dissolving" the sprite in the preset. Default: 1.0
+        PRJM_EVAL_F* x{};         //!< Sprite x position (position of the image center). Range from -1000 to 1000. Default: 0.5
+        PRJM_EVAL_F* y{};         //!< Sprite y position (position of the image center). Range from -1000 to 1000. Default: 0.5
+        PRJM_EVAL_F* sx{};        //!< Sprite x scaling factor. Range from -1000 to 1000. Default: 1.0
+        PRJM_EVAL_F* sy{};        //!< Sprite y scaling factor. Range from -1000 to 1000. Default: 1.0
+        PRJM_EVAL_F* rot{};       //!< Sprite rotation in radians (2*PI equals one full rotation). Default: 0.0
+        PRJM_EVAL_F* flipx{};     //!< If flag is non-zero, the sprite is flipped on the x axis. Default: 0.0
+        PRJM_EVAL_F* flipy{};     //!< If flag is non-zero, the sprite is flipped on the y axis. Default: 0.0
+        PRJM_EVAL_F* repeatx{};   //!< Repeat count of the image on the sprite quad on the x axis. Fractional values allowed. Range from 0.01 to 100.0. Default: 1.0
+        PRJM_EVAL_F* repeaty{};   //!< Repeat count of the image on the sprite quad on the y axis. Fractional values allowed. Range from 0.01 to 100.0. Default: 1.0
         PRJM_EVAL_F* blendmode{}; //!< Image blending mode. 0 = Alpha blending (default), 1 = Decal mode (no transparency), 2 = Additive blending, 3 = Source color blending, 4 = Color key blending. Default: 0
-        PRJM_EVAL_F* r{}; //!< Modulation color used in some blending modes. Default: 1.0
-        PRJM_EVAL_F* g{}; //!< Modulation color used in some blending modes. Default: 1.0
-        PRJM_EVAL_F* b{}; //!< Modulation color used in some blending modes. Default: 1.0
-        PRJM_EVAL_F* a{}; //!< Modulation color used in some blending modes. Default: 1.0
-
+        PRJM_EVAL_F* r{};         //!< Modulation color used in some blending modes. Default: 1.0
+        PRJM_EVAL_F* g{};         //!< Modulation color used in some blending modes. Default: 1.0
+        PRJM_EVAL_F* b{};         //!< Modulation color used in some blending modes. Default: 1.0
+        PRJM_EVAL_F* a{};         //!< Modulation color used in some blending modes. Default: 1.0
     };
 
-    CodeContext m_codeContext; //!< Sprite init and per-frame code.
-    std::shared_ptr<Renderer::Texture> m_texture; //!< The sprite image, loaded via a name like other textures in Milkdrop presets.
+    CodeContext m_codeContext;                         //!< Sprite init and per-frame code.
+    std::shared_ptr<Renderer::Texture> m_texture;      //!< The sprite image, loaded via a name like other textures in Milkdrop presets.
     Renderer::Sampler m_sampler{GL_REPEAT, GL_LINEAR}; //!< Texture sampler settings
-    std::weak_ptr<Renderer::Shader> m_spriteShader; //!< The shader used to draw the user sprite.
-    bool m_spriteDone{false}; //!< If true, the sprite will be removed from the list.
-
+    std::weak_ptr<Renderer::Shader> m_spriteShader;    //!< The shader used to draw the user sprite.
+    Renderer::Mesh m_mesh;                             //!< A simple quad.
+    bool m_spriteDone{false};                          //!< If true, the sprite will be removed from the list.
 };
 
 } // namespace UserSprites
diff --git a/src/libprojectM/UserSprites/Sprite.hpp b/src/libprojectM/UserSprites/Sprite.hpp
@@ -1,13 +1,10 @@
 #pragma once
 
-#include "UserSprites/SpriteException.hpp"
-
 #include <Preset.hpp>
 
 #include <Audio/FrameAudioData.hpp>
 
 #include <Renderer/RenderContext.hpp>
-#include <Renderer/RenderItem.hpp>
 
 #include <cstdint>
 #include <functional>
@@ -18,12 +15,14 @@
 namespace libprojectM {
 namespace UserSprites {
 
-class Sprite : public Renderer::RenderItem
+class Sprite
 {
 public:
     using Ptr = std::unique_ptr<Sprite>;
     using PresetList = std::vector<std::reference_wrapper<const std::unique_ptr<Preset>>>;
 
+    virtual ~Sprite() = default;
+
     /**
      * @brief Initializes the sprite instance for rendering.
      * @param spriteData The data for the sprite type.
diff --git a/src/libprojectM/UserSprites/SpriteManager.cpp b/src/libprojectM/UserSprites/SpriteManager.cpp
@@ -1,6 +1,7 @@
 #include "UserSprites/SpriteManager.hpp"
 
 #include "UserSprites/Factory.hpp"
+#include "UserSprites/SpriteException.hpp"
 
 #include <Renderer/Shader.hpp>
 
@@ -62,7 +63,8 @@ void SpriteManager::Draw(const Audio::FrameAudioData& audioData,
                          uint32_t outputFramebufferObject,
                          Sprite::PresetList presets)
 {
-    for (auto& idAndSprite : m_sprites) {
+    for (auto& idAndSprite : m_sprites)
+    {
         idAndSprite.second->Draw(audioData, renderContext, outputFramebufferObject, presets);
 
         if (idAndSprite.second->Done())
@@ -99,7 +101,8 @@ auto SpriteManager::ActiveSpriteCount() const -> uint32_t
 auto SpriteManager::ActiveSpriteIdentifiers() const -> std::vector<SpriteIdentifier>
 {
     std::vector<SpriteIdentifier> identifierList;
-    for (auto& idAndSprite : m_sprites) {
+    for (auto& idAndSprite : m_sprites)
+    {
         identifierList.emplace_back(idAndSprite.first);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`#include "UserSprites/MilkdropSprite.hpp"`
`2`	`2`
	`3`	`+#include "SpriteException.hpp"`
`3`	`4`	`#include "SpriteShaders.hpp"`
`4`	`5`
`5`	`6`	`#include <Preset.hpp>`
`@@ -24,19 +25,9 @@ namespace libprojectM {`
`24`	`25`	`namespace UserSprites {`
`25`	`26`
`26`	`27`	`MilkdropSprite::MilkdropSprite()`
	`28`	`+ : m_mesh(Renderer::VertexBufferUsage::DynamicDraw, false, true)`
`27`	`29`	`{`
`28`		`- RenderItem::Init();`
`29`		`-}`
`30`		`-`
`31`		`-void MilkdropSprite::InitVertexAttrib()`
`32`		`-{`
`33`		`- glEnableVertexAttribArray(0);`
`34`		`- glDisableVertexAttribArray(1);`
`35`		`- glEnableVertexAttribArray(2);`
`36`		`-`
`37`		`- glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position`
`38`		`- // Color (index 1) is passed as a 4-float constant vertex attribute.`
`39`		`- glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, u))); // Texture coordinate`
	`30`	`+ m_mesh.SetVertexCount(4);`
`40`	`31`	`}`
`41`	`32`
`42`	`33`	`void MilkdropSprite::Init(const std::string& spriteData, const Renderer::RenderContext& renderContext)`
`@@ -119,7 +110,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`119`	`110`	`m_spriteDone = *m_codeContext.done != 0.0;`
`120`	`111`	`bool burnIn = *m_codeContext.burn != 0.0;`
`121`	`112`
`122`		`- Quad vertices{};`
	`113`	`+ auto& vertices = m_mesh.Vertices().Get();`
`123`	`114`
`124`	`115`	`// Get values from expression code and clamp them where necessary.`
`125`	`116`	`float x = std::min(1000.0f, std::max(-1000.0f, static_cast<float>(m_codeContext.x) 2.0f - 1.0f));`
`@@ -139,14 +130,14 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`139`	`130`	`float a = std::min(1.0f, std::max(0.0f, (static_cast<float>(*m_codeContext.a))));`
`140`	`131`
`141`	`132`	`// ToDo: Move all translations to vertex shader`
`142`		`- vertices[0 + flipx].x = -sx;`
`143`		`- vertices[1 - flipx].x = sx;`
`144`		`- vertices[2 + flipx].x = -sx;`
`145`		`- vertices[3 - flipx].x = sx;`
`146`		`- vertices[0 + flipy * 2].y = -sy;`
`147`		`- vertices[1 + flipy * 2].y = -sy;`
`148`		`- vertices[2 - flipy * 2].y = sy;`
`149`		`- vertices[3 - flipy * 2].y = sy;`
	`133`	`+ vertices[0 + flipx].SetX(-sx);`
	`134`	`+ vertices[1 - flipx].SetX(sx);`
	`135`	`+ vertices[2 + flipx].SetX(-sx);`
	`136`	`+ vertices[3 - flipx].SetX(sx);`
	`137`	`+ vertices[0 + flipy * 2].SetY(-sy);`
	`138`	`+ vertices[1 + flipy * 2].SetY(-sy);`
	`139`	`+ vertices[2 - flipy * 2].SetY(sy);`
	`140`	`+ vertices[3 - flipy * 2].SetY(sy);`
`150`	`141`
`151`	`142`	`// First aspect ratio: adjust for non-1:1 images`
`152`	`143`	`{`
`@@ -157,15 +148,15 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`157`	`148`	`// Landscape image`
`158`	`149`	`for (auto& vertex : vertices)`
`159`	`150`	`{`
`160`		`- vertex.y *= aspect;`
	`151`	`+ vertex.SetY(vertex.Y() * aspect);`
`161`	`152`	`}`
`162`	`153`	`}`
`163`	`154`	`else`
`164`	`155`	`{`
`165`	`156`	`// Portrait image`
`166`	`157`	`for (auto& vertex : vertices)`
`167`	`158`	`{`
`168`		`- vertex.x /= aspect;`
	`159`	`+ vertex.SetX(vertex.X() / aspect);`
`169`	`160`	`}`
`170`	`161`	`}`
`171`	`162`	`}`
`@@ -177,18 +168,17 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`177`	`168`
`178`	`169`	`for (auto& vertex : vertices)`
`179`	`170`	`{`
`180`		`- float rotX = vertex.x * cos_rot - vertex.y * sin_rot;`
`181`		`- float rotY = vertex.x * sin_rot + vertex.y * cos_rot;`
`182`		`- vertex.x = rotX;`
`183`		`- vertex.y = rotY;`
	`171`	`+ float rotX = vertex.X() * cos_rot - vertex.Y() * sin_rot;`
	`172`	`+ float rotY = vertex.X() * sin_rot + vertex.Y() * cos_rot;`
	`173`	`+ vertex = {rotX, rotY};`
`184`	`174`	`}`
`185`	`175`	`}`
`186`	`176`
`187`	`177`	`// Translation`
`188`	`178`	`for (auto& vertex : vertices)`
`189`	`179`	`{`
`190`		`- vertex.x += x;`
`191`		`- vertex.y += y;`
	`180`	`+ vertex.SetX(vertex.X() + x);`
	`181`	`+ vertex.SetY(vertex.Y() + y);`
`192`	`182`	`}`
`193`	`183`
`194`	`184`	`// Second aspect ratio: normalize to width of screen`
`@@ -199,14 +189,14 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`199`	`189`	`{`
`200`	`190`	`for (auto& vertex : vertices)`
`201`	`191`	`{`
`202`		`- vertex.y *= aspect;`
	`192`	`+ vertex.SetY(vertex.Y() * aspect);`
`203`	`193`	`}`
`204`	`194`	`}`
`205`	`195`	`else`
`206`	`196`	`{`
`207`	`197`	`for (auto& vertex : vertices)`
`208`	`198`	`{`
`209`		`- vertex.x /= aspect;`
	`199`	`+ vertex.SetX(vertex.X() / aspect);`
`210`	`200`	`}`
`211`	`201`	`}`
`212`	`202`	`}`
`@@ -219,19 +209,15 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`219`	`209`	`float dtu = 0.5f;`
`220`	`210`	`float dtv = 0.5f;`
`221`	`211`
`222`		`- vertices[0].u = -dtu;`
`223`		`- vertices[1].u = dtu;`
`224`		`- vertices[2].u = -dtu;`
`225`		`- vertices[3].u = dtu;`
`226`		`- vertices[0].v = -dtv;`
`227`		`- vertices[1].v = -dtv;`
`228`		`- vertices[2].v = dtv;`
`229`		`- vertices[3].v = dtv;`
	`212`	`+ m_mesh.UVs().Set({{-dtu, -dtv},`
	`213`	`+ {dtu, -dtv},`
	`214`	`+ {-dtu, dtv},`
	`215`	`+ {dtu, dtv}});`
`230`	`216`
`231`		`- for (auto& vertex : vertices)`
	`217`	`+ for (auto& uv : m_mesh.UVs().Get())`
`232`	`218`	`{`
`233`		`- vertex.u = (vertex.u - 0.0f) * repeatx + 0.5f;`
`234`		`- vertex.v = (vertex.v - 0.0f) * repeaty + 0.5f;`
	`219`	`+ uv = {(uv.U() - 0.0f) * repeatx + 0.5f,`
	`220`	`+ (uv.V() - 0.0f) * repeaty + 0.5f};`
`235`	`221`	`}`
`236`	`222`	`}`
`237`	`223`
`@@ -243,9 +229,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`243`	`229`	`m_texture->Bind(0);`
`244`	`230`	`m_sampler.Bind(0);`
`245`	`231`
`246`		`- glBindVertexArray(m_vaoID);`
`247`		`- glBindBuffer(GL_ARRAY_BUFFER, m_vboID);`
`248`		`- glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_DYNAMIC_DRAW);`
	`232`	`+ m_mesh.Update();`
`249`	`233`
`250`	`234`	`glVertexAttrib4f(1, r, g, b, a);`
`251`	`235`
`@@ -275,7 +259,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`275`	`259`	`}`
`276`	`260`
`277`	`261`	`// Draw to current output buffer`
`278`		`- glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);`
	`262`	`+ m_mesh.Draw();`
`279`	`263`
`280`	`264`	`if (burnIn)`
`281`	`265`	`{`
`@@ -288,7 +272,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`288`	`272`	`}`
`289`	`273`
`290`	`274`	`preset.get()->BindFramebuffer();`
`291`		`- glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);`
	`275`	`+ m_mesh.Draw();`
`292`	`276`	`}`
`293`	`277`
`294`	`278`	`// Reset to original FBO`
`@@ -300,6 +284,7 @@ void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,`
`300`	`284`	`glBindBuffer(GL_ARRAY_BUFFER, 0);`
`301`	`285`	`glBindVertexArray(0);`
`302`	`286`	`m_texture->Unbind(0);`
	`287`	`+ Renderer::Mesh::Unbind();`
`303`	`288`	`Renderer::Shader::Unbind();`
`304`	`289`	`}`
`305`	`290`