diff --git a/src/libprojectM/Audio/AudioConstants.hpp b/src/libprojectM/Audio/AudioConstants.hpp
new file mode 100644
index 000000000..7e4f18a14
--- /dev/null
+++ b/src/libprojectM/Audio/AudioConstants.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+namespace libprojectM {
+namespace Audio {
+
+static constexpr int WaveformSamples = 576; //!< Number of waveform data samples available for rendering a frame.
+static constexpr int SpectrumSamples = 512; //!< Number of spectrum analyzer samples.
+
+} // namespace Audio
+} // namespace libprojectM
diff --git a/src/libprojectM/Audio/BeatDetect.cpp b/src/libprojectM/Audio/BeatDetect.cpp
index 5343116f5..68c3797bb 100755
--- a/src/libprojectM/Audio/BeatDetect.cpp
+++ b/src/libprojectM/Audio/BeatDetect.cpp
@@ -67,6 +67,27 @@ auto BeatDetect::GetPCMScale() const noexcept -> float
 }
 
 
+auto BeatDetect::GetFrameAudioData() const -> FrameAudioData
+{
+    FrameAudioData data{};
+
+    pcm.GetPcm(data.waveformLeft.data(), CHANNEL_L, WaveformSamples);
+    pcm.GetPcm(data.waveformRight.data(), CHANNEL_R, WaveformSamples);
+    pcm.GetSpectrum(data.spectrumLeft.data(), CHANNEL_L, SpectrumSamples);
+
+    data.vol = vol;
+    data.volAtt = volAtt;
+
+    data.bass = bass;
+    data.bassAtt = bassAtt;
+    data.mid = mid;
+    data.midAtt = midAtt;
+    data.treb = treb;
+    data.trebAtt = trebAtt;
+
+    return data;
+}
+
 auto BeatDetect::CalculateBeatStatistics() -> void
 {
     volOld = vol;
@@ -115,6 +136,7 @@ auto BeatDetect::CalculateBeatStatistics() -> void
 }
 
 
+
 auto BeatDetect::LowPassFilter::Update(float nextValue) noexcept -> void
 {
     m_current -= m_buffer[m_bufferPos] / bufferLength;
diff --git a/src/libprojectM/Audio/BeatDetect.hpp b/src/libprojectM/Audio/BeatDetect.hpp
index ff1ba5647..c0a8bef61 100755
--- a/src/libprojectM/Audio/BeatDetect.hpp
+++ b/src/libprojectM/Audio/BeatDetect.hpp
@@ -23,6 +23,7 @@
  */
 #pragma once
 
+#include "FrameAudioData.hpp"
 #include "PCM.hpp"
 
 #include <array>
@@ -50,6 +51,13 @@ public:
     [[nodiscard]]
     auto GetPCMScale() const noexcept -> float;
 
+    /**
+     * @brief Returns a filled FrameAudioData structure for the current frame.
+     * @return A FrameAudioData structure with waveform, spectrum beat detection data.
+     */
+    [[nodiscard]]
+    auto GetFrameAudioData() const -> FrameAudioData;
+
     float beatSensitivity{1.f};
 
     float treb{0.f};
diff --git a/src/libprojectM/Audio/FrameAudioData.hpp b/src/libprojectM/Audio/FrameAudioData.hpp
index 28c786735..0cd56e2be 100644
--- a/src/libprojectM/Audio/FrameAudioData.hpp
+++ b/src/libprojectM/Audio/FrameAudioData.hpp
@@ -6,7 +6,7 @@
  */
 #pragma once
 
-#include "Constants.hpp"
+#include "AudioConstants.hpp"
 
 #include <array>
 
diff --git a/src/libprojectM/CMakeLists.txt b/src/libprojectM/CMakeLists.txt
index 124d10a35..4d066a685 100644
--- a/src/libprojectM/CMakeLists.txt
+++ b/src/libprojectM/CMakeLists.txt
@@ -47,7 +47,7 @@ add_library(projectM_main OBJECT
         resource.h
         wipemalloc.cpp
         wipemalloc.h
-        )
+        Audio/AudioConstants.hpp)
 
 target_link_libraries(projectM_main
         PUBLIC
diff --git a/src/libprojectM/MilkdropPreset/BlurTexture.cpp b/src/libprojectM/MilkdropPreset/BlurTexture.cpp
index b4b8a18d2..0075892c6 100644
--- a/src/libprojectM/MilkdropPreset/BlurTexture.cpp
+++ b/src/libprojectM/MilkdropPreset/BlurTexture.cpp
@@ -1,6 +1,6 @@
 #include "BlurTexture.hpp"
 
-#include <Renderer/StaticGlShaders.h>
+#include <Renderer/StaticGlShaders.hpp>
 
 #include <array>
 
diff --git a/src/libprojectM/MilkdropPreset/Border.cpp b/src/libprojectM/MilkdropPreset/Border.cpp
index 3d888c1d9..e43f8a0e2 100644
--- a/src/libprojectM/MilkdropPreset/Border.cpp
+++ b/src/libprojectM/MilkdropPreset/Border.cpp
@@ -2,8 +2,9 @@
 
 #include <glm/gtc/type_ptr.hpp>
 
-Border::Border()
+Border::Border(PresetState& presetState)
     : RenderItem()
+    , m_presetState(presetState)
 {
     RenderItem::Init();
 }
@@ -11,54 +12,60 @@ Border::Border()
 void Border::InitVertexAttrib()
 {
     glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*) 0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
     glDisableVertexAttribArray(1);
 }
 
-void Border::Draw(RenderContext& context)
+void Border::Draw(const PerFrameContext& presetPerFrameContext)
 {
-    //Draw Borders
-    float of = outer_size * .5;
-    float iff = inner_size * .5;
-    float texof = 1.0 - of;
+    // Draw Borders
+    float const outerBorderSize = static_cast<float>(*presetPerFrameContext.ob_size) * .5f;
+    float const innerBorderSize = static_cast<float>(*presetPerFrameContext.ib_size) * .5f;
+    float const texelOffset = 1.0f - outerBorderSize;
 
-    float points[40] = {
+    std::array<std::array<float, 4>, 10> const points = {{
         // Outer
-        0, 0, of, 0,
-        0, 1, of, texof,
-        1, 1, texof, texof,
-        1, 0, texof, of,
-        of, 0, of, of,
+        {0.0f, 0.0f, outerBorderSize, 0.0f},
+        {0.0f, 1.0f, outerBorderSize, texelOffset},
+        {1.0f, 1.0f, texelOffset, texelOffset},
+        {1.0f, 0.0f, texelOffset, outerBorderSize},
+        {outerBorderSize, 0.0f, outerBorderSize, outerBorderSize},
 
         // Inner
-        of, of, of + iff, of,
-        of, texof, of + iff, texof - iff,
-        texof, texof, texof - iff, texof - iff,
-        texof, of, texof - iff, of + iff,
-        of + iff, of, of + iff, of + iff,
-    };
+        {outerBorderSize, outerBorderSize, outerBorderSize + innerBorderSize, outerBorderSize},
+        {outerBorderSize, texelOffset, outerBorderSize + innerBorderSize, texelOffset - innerBorderSize},
+        {texelOffset, texelOffset, texelOffset - innerBorderSize, texelOffset - innerBorderSize},
+        {texelOffset, outerBorderSize, texelOffset - innerBorderSize, outerBorderSize + innerBorderSize},
+        {outerBorderSize + innerBorderSize, outerBorderSize, outerBorderSize + innerBorderSize, outerBorderSize + innerBorderSize},
+    }};
 
     glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
 
-    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 40, NULL, GL_DYNAMIC_DRAW);
-    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 40, points, GL_DYNAMIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 40, points.data(), GL_DYNAMIC_DRAW);
 
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 
-    glUseProgram(context.programID_v2f_c4f);
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
-    glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
+    glVertexAttrib4f(1,
+                     static_cast<float>(*presetPerFrameContext.ob_r),
+                     static_cast<float>(*presetPerFrameContext.ob_g),
+                     static_cast<float>(*presetPerFrameContext.ob_b),
+                     static_cast<float>(*presetPerFrameContext.ob_a));
 
-    glVertexAttrib4f(1, outer_r, outer_g, outer_b, outer_a * masterAlpha);
-
-    //no additive drawing for borders
+    // No additive drawing for borders
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glBindVertexArray(m_vaoID);
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 10);
 
-    glVertexAttrib4f(1, inner_r, inner_g, inner_b, inner_a * masterAlpha);
+    glVertexAttrib4f(1,
+                     static_cast<float>(*presetPerFrameContext.ib_r),
+                     static_cast<float>(*presetPerFrameContext.ib_g),
+                     static_cast<float>(*presetPerFrameContext.ib_b),
+                     static_cast<float>(*presetPerFrameContext.ib_a));
 
     // 1st pass for inner
     glDrawArrays(GL_TRIANGLE_STRIP, 10, 10);
diff --git a/src/libprojectM/MilkdropPreset/Border.hpp b/src/libprojectM/MilkdropPreset/Border.hpp
index c27f2f2d4..e71ab532f 100644
--- a/src/libprojectM/MilkdropPreset/Border.hpp
+++ b/src/libprojectM/MilkdropPreset/Border.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "PerFrameContext.hpp"
+#include "PresetState.hpp"
+
 #include "Renderer/RenderItem.hpp"
 
 /**
@@ -8,29 +11,18 @@
 class Border : public RenderItem
 {
 public:
+    Border() = delete;
 
-    /**
-     * Constructor. Initializes the required OpenGL data structures.
-     */
-    Border();
+    explicit Border(PresetState& presetState);
 
-    void InitVertexAttrib();
+    void InitVertexAttrib() override;
 
     /**
      * Draws the border.
-     * @param context The render context data.
+     * @param presetPerFrameContext The per-frame context variables.
      */
-    void Draw(RenderContext &context);
+    void Draw(const PerFrameContext& presetPerFrameContext);
 
-    float outer_size{ 0.0 }; //!< Outer border width
-    float outer_r{ 0.0 }; //!< Outer border color, red channel.
-    float outer_g{ 0.0 }; //!< Outer border color, green channel.
-    float outer_b{ 0.0 }; //!< Outer border color, blue channel.
-    float outer_a{ 0.0 }; //!< Outer border color, alpha channel.
-
-    float inner_size{ 0.0 }; //!< Inner border width
-    float inner_r{ 0.0 }; //!< Inner border color, red channel.
-    float inner_g{ 0.0 }; //!< Inner border color, green channel.
-    float inner_b{ 0.0 }; //!< Inner border color, blue channel.
-    float inner_a{ 0.0 }; //!< Inner border color, alpha channel.
+private:
+    PresetState& m_presetState; //!< The global preset state.
 };
diff --git a/src/libprojectM/MilkdropPreset/Constants.hpp b/src/libprojectM/MilkdropPreset/Constants.hpp
index ee121b7d5..0229601f1 100644
--- a/src/libprojectM/MilkdropPreset/Constants.hpp
+++ b/src/libprojectM/MilkdropPreset/Constants.hpp
@@ -4,14 +4,13 @@
  */
 #pragma once
 
+#include <Audio/AudioConstants.hpp>
+
 static constexpr int QVarCount = 32; //!< Number of Q variables available.
 static constexpr int TVarCount = 8; //!< Number of T variables available.
 
 static constexpr int CustomWaveformCount = 4; //!< Number of custom waveforms (expression-driven) which can be used in a preset.
 static constexpr int CustomShapeCount = 4; //!< Number of custom shapes (expression-driven) which can be used in a preset.
 
-static constexpr int WaveformSamples = 576; //!< Number of waveform data samples available for rendering a frame.
-static constexpr int SpectrumSamples = 512; //!< Number of spectrum analyzer samples.
-
 static constexpr int RenderWaveformSamples = 480; //!< Number of custom waveform data samples available for rendering a frame.
 static constexpr int WaveformMaxPoints = 512; //!< Maximum number of waveform points.
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.cpp b/src/libprojectM/MilkdropPreset/CustomShape.cpp
index ae2255180..3551c9d44 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.cpp
@@ -156,7 +156,7 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
             glActiveTexture(GL_TEXTURE0);
             if (m_image.empty())
             {
-                glBindTexture(GL_TEXTURE_2D, m_presetState.renderContext.textureManager->getMainTexture()->texID);
+                glBindTexture(GL_TEXTURE_2D, m_presetState.mainTextureId);
             }
             else
             {
@@ -170,7 +170,7 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
                 else
                 {
                     // No texture found, fall back to main texture.
-                    glBindTexture(GL_TEXTURE_2D, m_presetState.renderContext.textureManager->getMainTexture()->texID);
+                    glBindTexture(GL_TEXTURE_2D, m_presetState.mainTextureId);
                 }
             }
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@@ -191,11 +191,9 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
 
             glBufferData(GL_ARRAY_BUFFER, sizeof(ShapeVertexShaderData) * (*m_perFrameContext.sides + 2), vertexData.data(), GL_DYNAMIC_DRAW);
 
-            glUseProgram(m_presetState.renderContext.programID_v2f_c4f_t2f);
-
-            glUniformMatrix4fv(m_presetState.renderContext.uniform_v2f_c4f_t2f_vertex_transformation, 1, GL_FALSE,
-                               glm::value_ptr(m_presetState.renderContext.mat_ortho));
-            glUniform1i(m_presetState.renderContext.uniform_v2f_c4f_t2f_frag_texture_sampler, 0);
+            m_presetState.texturedShader.Bind();
+            m_presetState.texturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
+            m_presetState.texturedShader.SetUniformInt("texture_sampler", 0);
 
             glBindVertexArray(m_vaoID_texture);
             glDrawArrays(GL_TRIANGLE_FAN, 0, *m_perFrameContext.sides + 2);
@@ -211,10 +209,8 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
 
             glBufferData(GL_ARRAY_BUFFER, sizeof(ShapeVertexShaderData) * (*m_perFrameContext.sides + 2), vertexData.data(), GL_DYNAMIC_DRAW);
 
-            glUseProgram(m_presetState.renderContext.programID_v2f_c4f);
-
-            glUniformMatrix4fv(m_presetState.renderContext.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE,
-                               glm::value_ptr(m_presetState.renderContext.mat_ortho));
+            m_presetState.untexturedShader.Bind();
+            m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
             glBindVertexArray(m_vaoID_not_texture);
             glDrawArrays(GL_TRIANGLE_FAN, 0, *m_perFrameContext.sides + 2);
@@ -231,10 +227,9 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
                 points[i].y = vertexData[i + 1].point_y;
             }
 
-            glUseProgram(m_presetState.renderContext.programID_v2f_c4f);
+            m_presetState.untexturedShader.Bind();
+            m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
-            glUniformMatrix4fv(m_presetState.renderContext.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE,
-                               glm::value_ptr(m_presetState.renderContext.mat_ortho));
             glVertexAttrib4f(1,
                              *m_perFrameContext.border_r,
                              *m_perFrameContext.border_g,
@@ -288,7 +283,6 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
                 glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair) * (*m_perFrameContext.sides), points.data(), GL_DYNAMIC_DRAW);
                 glDrawArrays(GL_LINE_LOOP, 0, *m_perFrameContext.sides);
             }
-
         }
     }
 
@@ -298,7 +292,8 @@ void CustomShape::Draw(const PerFrameContext& presetPerFrameContext)
 #if USE_GLES == 0
     glDisable(GL_LINE_SMOOTH);
 #endif
-    glUseProgram(0);
+
+    Shader::Unbind();
 }
 
 void CustomShape::LoadPerFrameEvaluationVariables(const PerFrameContext& presetPerFrameContext)
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
index c0cea9cb0..462bf8e51 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
@@ -12,7 +12,7 @@
 #include <algorithm>
 #include <cmath>
 
-static constexpr int CustomWaveformMaxSamples = std::max(RenderWaveformSamples, SpectrumSamples);
+static constexpr int CustomWaveformMaxSamples = std::max(RenderWaveformSamples, libprojectM::Audio::SpectrumSamples);
 
 CustomWaveform::CustomWaveform(PresetState& presetState)
     : RenderItem()
@@ -72,12 +72,12 @@ void CustomWaveform::CompileCodeAndRunInitExpressions(const PerFrameContext& pre
 void CustomWaveform::Draw(const PerFrameContext& presetPerFrameContext)
 {
     // Some safety assertions if someone plays around and changes the values in the wrong way.
-    static_assert(WaveformMaxPoints <= SpectrumSamples, "CustomWaveformMaxPoints is larger than SpectrumSamples");
-    static_assert(WaveformMaxPoints <= WaveformSamples, "CustomWaveformMaxPoints is larger than WaveformSamples");
+    static_assert(WaveformMaxPoints <= libprojectM::Audio::SpectrumSamples, "CustomWaveformMaxPoints is larger than SpectrumSamples");
+    static_assert(WaveformMaxPoints <= libprojectM::Audio::WaveformSamples, "CustomWaveformMaxPoints is larger than WaveformSamples");
     static_assert(RenderWaveformSamples <= WaveformMaxPoints, "CustomWaveformSamples is larger than CustomWaveformMaxPoints");
 
     int sampleCount{m_samples};
-    int const maxSampleCount{m_spectrum ? SpectrumSamples : RenderWaveformSamples};
+    int const maxSampleCount{m_spectrum ? libprojectM::Audio::SpectrumSamples : RenderWaveformSamples};
     sampleCount = std::min(sampleCount, maxSampleCount);
     sampleCount -= m_sep;
 
@@ -163,9 +163,8 @@ void CustomWaveform::Draw(const PerFrameContext& presetPerFrameContext)
     std::vector<ColoredPoint> pointsSmoothed(sampleCount * 2);
     auto smoothedVertexCount = SmoothWave(pointsTransformed.data(), sampleCount, pointsSmoothed.data());
 
-    glUseProgram(m_presetState.renderContext.programID_v2f_c4f);
-
-    glUniformMatrix4fv(m_presetState.renderContext.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(m_presetState.renderContext.mat_ortho));
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
     if (m_additive)
     {
@@ -242,7 +241,7 @@ void CustomWaveform::Draw(const PerFrameContext& presetPerFrameContext)
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
 
-    glUseProgram(0);
+    Shader::Unbind();
 
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
index c619004eb..e620fdd56 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
@@ -2,43 +2,44 @@
 
 #include <glm/gtc/type_ptr.hpp>
 
-DarkenCenter::DarkenCenter()
+DarkenCenter::DarkenCenter(PresetState& presetState)
     : RenderItem()
+    , m_presetState(presetState)
 {
     RenderItem::Init();
 }
 
 void DarkenCenter::InitVertexAttrib()
 {
-    float points_colors[6][6] = {
-        { 0.5,  0.5,  0, 0, 0, (3.0f / 32.0f) * masterAlpha },
-        { 0.45, 0.5,  0, 0, 0, 0 },
-        { 0.5,  0.45, 0, 0, 0, 0 },
-        { 0.55, 0.5,  0, 0, 0, 0 },
-        { 0.5,  0.55, 0, 0, 0, 0 },
-        { 0.45, 0.5,  0, 0, 0, 0 }};
+    std::array<std::array<float, 6>, 6> points_colors = {{{0.5, 0.5, 0, 0, 0, 3.0f / 32.0f},
+                                                          {0.45, 0.5, 0, 0, 0, 0},
+                                                          {0.5, 0.45, 0, 0, 0, 0},
+                                                          {0.55, 0.5, 0, 0, 0, 0},
+                                                          {0.5, 0.55, 0, 0, 0, 0},
+                                                          {0.45, 0.5, 0, 0, 0, 0}}};
 
     glEnableVertexAttribArray(0);
     glEnableVertexAttribArray(1);
 
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*) 0); // points
-    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 6, (void*) (sizeof(float) * 2)); // colors
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 6, nullptr);                                    // points
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 6, reinterpret_cast<void*>(sizeof(float) * 2)); // colors
 
-    glBufferData(GL_ARRAY_BUFFER, sizeof(points_colors), points_colors, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(points_colors), points_colors.data(), GL_STATIC_DRAW);
 }
 
 
-void DarkenCenter::Draw(RenderContext& context)
+void DarkenCenter::Draw()
 {
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    glUseProgram(context.programID_v2f_c4f);
-
-    glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
     glBindVertexArray(m_vaoID);
 
     glDrawArrays(GL_TRIANGLE_FAN, 0, 6);
 
     glBindVertexArray(0);
+
+    Shader::Unbind();
 }
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
index 9ee3d976e..6177f8059 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "PresetState.hpp"
+
 #include "Renderer/RenderItem.hpp"
 
 /**
@@ -8,17 +10,17 @@
 class DarkenCenter : public RenderItem
 {
 public:
+    DarkenCenter() = delete;
 
-    /**
-     * Constructor. Initializes the required OpenGL data structures.
-     */
-    DarkenCenter();
+    explicit DarkenCenter(PresetState& presetState);
 
     void InitVertexAttrib();
 
     /**
      * Applies the darkening area.
-     * @param context The render context data.
      */
-    void Draw(RenderContext &context);
+    void Draw();
+
+private:
+    PresetState& m_presetState; //!< The global preset state.
 };
diff --git a/src/libprojectM/MilkdropPreset/Filters.cpp b/src/libprojectM/MilkdropPreset/Filters.cpp
index cddeadd10..1d88708be 100644
--- a/src/libprojectM/MilkdropPreset/Filters.cpp
+++ b/src/libprojectM/MilkdropPreset/Filters.cpp
@@ -4,130 +4,100 @@
 
 #include "Renderer/ShaderEngine.hpp"
 
-#include <glm/gtc/type_ptr.hpp>
+Filters::Filters(PresetState& presetState)
+    : RenderItem()
+    , m_presetState(presetState)
+{
+    RenderItem::Init();
+}
 
-void Brighten::InitVertexAttrib() {
-    float points[4][2] = {{-0.5, -0.5},
-                      {-0.5,  0.5},
-                      { 0.5,  0.5},
-                      { 0.5,  -0.5}};
+void Filters::InitVertexAttrib()
+{
+    std::array<std::array<float, 2>, 4> points = {{{-0.5, -0.5},
+                                                   {-0.5, 0.5},
+                                                   {0.5, 0.5},
+                                                   {0.5, -0.5}}};
 
-    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points.data(), GL_STATIC_DRAW);
 
     glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
     glDisableVertexAttribArray(1);
 }
 
-void Brighten::Draw(RenderContext &context)
+void Filters::Brighten()
 {
-    glUseProgram(context.programID_v2f_c4f);
-
-    glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
     glBindVertexArray(m_vaoID);
 
     glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
-	glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
-	glBlendFunc(GL_ZERO, GL_DST_COLOR);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
-	glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glBlendFunc(GL_ZERO, GL_DST_COLOR);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glBindVertexArray(0);
+
+    Shader::Unbind();
 }
 
-void Darken::InitVertexAttrib() {
-    float points[4][2] = {{-0.5, -0.5},
-                      {-0.5,  0.5},
-                      { 0.5,  0.5},
-                      { 0.5,  -0.5}};
-
-    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
-
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-    glDisableVertexAttribArray(1);
-}
-
-void Darken::Draw(RenderContext &context)
+void Filters::Darken()
 {
-    glUseProgram(context.programID_v2f_c4f);
-
-    glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
     glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
 
-	glBlendFunc(GL_ZERO, GL_DST_COLOR);
+    glBlendFunc(GL_ZERO, GL_DST_COLOR);
 
     glBindVertexArray(m_vaoID);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     glBindVertexArray(0);
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    Shader::Unbind();
 }
 
-void Invert::InitVertexAttrib() {
-    float points[4][2] = {{-0.5, -0.5},
-                      {-0.5,  0.5},
-                      { 0.5,  0.5},
-                      { 0.5,  -0.5}};
-
-    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
-
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-    glDisableVertexAttribArray(1);
-}
-
-void Invert::Draw(RenderContext &context)
+void Filters::Invert()
 {
-
-    glUseProgram(context.programID_v2f_c4f);
-
-    glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
     glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
 
-	glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
+    glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
 
     glBindVertexArray(m_vaoID);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     glBindVertexArray(0);
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    Shader::Unbind();
 }
 
-void Solarize::InitVertexAttrib() {
-    float points[4][2] = {{-0.5, -0.5},
-                          {-0.5,  0.5},
-                          { 0.5,  0.5},
-                          { 0.5,  -0.5}};
-
-    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
-
-    glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
-    glDisableVertexAttribArray(1);
-}
-
-void Solarize::Draw(RenderContext &context)
+void Filters::Solarize()
 {
-    glUseProgram(context.programID_v2f_c4f);
-
-    glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
 
     glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
 
-	glBlendFunc(GL_ZERO, GL_ONE_MINUS_DST_COLOR);
+    glBlendFunc(GL_ZERO, GL_ONE_MINUS_DST_COLOR);
 
     glBindVertexArray(m_vaoID);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
-	glBlendFunc(GL_DST_COLOR, GL_ONE);
-	glDrawArrays(GL_TRIANGLE_FAN,0,4);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glBlendFunc(GL_DST_COLOR, GL_ONE);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
     glBindVertexArray(0);
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    Shader::Unbind();
 }
diff --git a/src/libprojectM/MilkdropPreset/Filters.hpp b/src/libprojectM/MilkdropPreset/Filters.hpp
index 9f999f262..0bbe964c6 100644
--- a/src/libprojectM/MilkdropPreset/Filters.hpp
+++ b/src/libprojectM/MilkdropPreset/Filters.hpp
@@ -1,35 +1,28 @@
 #pragma once
 
-#include "Renderer/RenderItem.hpp"
+#include "PresetState.hpp"
 
-class Brighten : public RenderItem
+#include <Renderer/RenderItem.hpp>
+
+class Filters : public RenderItem
 {
 public:
-    Brighten(){ Init(); }
-    void InitVertexAttrib();
-	void Draw(RenderContext &context);
-};
+    Filters() = delete;
+    explicit Filters(PresetState& presetState);
 
-class Darken : public RenderItem
-{
-public:
-    Darken(){ Init(); }
     void InitVertexAttrib();
-	void Draw(RenderContext &context);
-};
 
-class Invert : public RenderItem
-{
-public:
-    Invert(){ Init(); }
-    void InitVertexAttrib();
-	void Draw(RenderContext &context);
-};
+    /**
+     * @brief Brightens the image
+     */
+    void Brighten();
 
-class Solarize : public RenderItem
-{
-public:
-    Solarize(){ Init(); }
-    void InitVertexAttrib();
-	void Draw(RenderContext &context);
+    void Darken();
+
+    void Invert();
+
+    void Solarize();
+
+private:
+    PresetState& m_presetState; //!< The global preset state.
 };
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
index cf5b0a78a..29126b197 100755
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
@@ -34,7 +34,11 @@
 MilkdropPreset::MilkdropPreset(std::istream& presetData)
     : m_perFrameContext(m_state.globalMemory, &m_state.globalRegisters)
     , m_perPixelContext(m_state.globalMemory, &m_state.globalRegisters)
+    , m_motionVectors(m_state)
     , m_waveform(m_state)
+    , m_darkenCenter(m_state)
+    , m_border(m_state)
+    , m_filters(m_state)
 {
     Load(presetData);
 }
@@ -44,7 +48,11 @@ MilkdropPreset::MilkdropPreset(const std::string& absoluteFilePath)
     : m_absoluteFilePath(absoluteFilePath)
     , m_perFrameContext(m_state.globalMemory, &m_state.globalRegisters)
     , m_perPixelContext(m_state.globalMemory, &m_state.globalRegisters)
+    , m_motionVectors(m_state)
     , m_waveform(m_state)
+    , m_darkenCenter(m_state)
+    , m_border(m_state)
+    , m_filters(m_state)
 {
     Load(absoluteFilePath);
 }
@@ -139,6 +147,7 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
 {
     m_state.audioData = audioData;
     m_state.renderContext = renderContext;
+    m_state.mainTextureId = m_framebuffer.GetColorAttachmentTexture(1, 0);
 
     // Update framebuffer size if needed
     m_framebuffer.SetSize(renderContext.viewportSizeX, renderContext.viewportSizeY);
@@ -147,27 +156,24 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     PerFrameUpdate();
 
     // Motion vector field. Drawn to the previous frame texture before warping it.
-    m_framebuffer.Bind(1);
-    // ToDo: Move this to the draw call and pass in the per-frame context.
-    m_motionVectors.r = static_cast<float>(*m_perFrameContext.mv_r);
-    m_motionVectors.g = static_cast<float>(*m_perFrameContext.mv_g);
-    m_motionVectors.b = static_cast<float>(*m_perFrameContext.mv_b);
-    m_motionVectors.a = static_cast<float>(*m_perFrameContext.mv_a);
-    m_motionVectors.length = static_cast<float>(*m_perFrameContext.mv_l);
-    m_motionVectors.x_num = static_cast<float>(*m_perFrameContext.mv_x);
-    m_motionVectors.y_num = static_cast<float>(*m_perFrameContext.mv_y);
-    m_motionVectors.x_offset = static_cast<float>(*m_perFrameContext.mv_dx);
-    m_motionVectors.y_offset = static_cast<float>(*m_perFrameContext.mv_dy);
-    m_motionVectors.Draw(renderContext);
+    //m_framebuffer.Bind(1);
+    m_motionVectors.Draw(m_perFrameContext);
 
     // We now draw to the first framebuffer, but read from the second one for warping.
-    m_framebuffer.BindRead(1);
-    m_framebuffer.BindDraw(0);
+    //m_framebuffer.BindRead(1);
+    //m_framebuffer.BindDraw(0);
+
+    // TEST: Copy for now, no warp
+    //glBlitFramebuffer(0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
+    //                  0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
+    //                  GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
     // Draw previous frame image warped via per-pixel mesh and warp shader
     // ToDo: ComputeGridAlphaValues
     // ToDo: Per-Pixel and warp stuff
 
+    //m_framebuffer.Bind(0);
+
     // Draw audio-data-related stuff
     for (auto& shape : m_customShapes)
     {
@@ -177,23 +183,35 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     {
         wave->Draw(m_perFrameContext);
     }
-    m_waveform.Draw();
+    m_waveform.Draw(m_perFrameContext);
 
-    // ToDo: Sprite drawing would go here.
+    // Done in DrawSprites() in Milkdrop
+    if (*m_perFrameContext.darken_center > 0)
+    {
+        m_darkenCenter.Draw();
+    }
+    m_border.Draw(m_perFrameContext);
 
     // Todo: Song title anim would go here
 
     // Copy pixels from framebuffer index 0 to 1
-    m_framebuffer.BindRead(0);
-    m_framebuffer.BindDraw(1);
-    glBlitFramebuffer(0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
-                      0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
-                      GL_COLOR_BUFFER_BIT, GL_NEAREST);
+    //m_framebuffer.BindRead(0);
+    //m_framebuffer.BindDraw(1);
+    //glBlitFramebuffer(0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
+    //                  0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
+    //                  GL_COLOR_BUFFER_BIT, GL_NEAREST);
 
     // ToDo: Apply composite shader
-    m_framebuffer.Bind(0);
+    //m_framebuffer.Bind(0);
 
     // ToDo: Draw user sprites (can have evaluated code)
+
+    // TEST: Copy result to default framebuffer
+    //glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+    //glBlitFramebuffer(0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
+    //                  0, 0, renderContext.viewportSizeX, renderContext.viewportSizeY,
+    //                  GL_COLOR_BUFFER_BIT, GL_NEAREST);
+
 }
 
 
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
index c077f3727..84464e693 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
@@ -107,5 +107,9 @@ private:
     std::array<std::unique_ptr<CustomWaveform>, CustomWaveformCount> m_customWaveforms; //!< Custom waveforms in this preset.
     std::array<std::unique_ptr<CustomShape>, CustomShapeCount> m_customShapes; //!< Custom shapes in this preset.
 
+    DarkenCenter m_darkenCenter; //!< Center darkening effect.
+    Border m_border; //!< Inner/outer borders.
+    Filters m_filters; //!< Various post-processing filters, applied if no composite shader is used.
+
     friend class MilkdropPresetFactory;
 };
diff --git a/src/libprojectM/MilkdropPreset/MilkdropShader.cpp b/src/libprojectM/MilkdropPreset/MilkdropShader.cpp
index 494fa3010..df965b5df 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropShader.cpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropShader.cpp
@@ -2,7 +2,7 @@
 
 #include "PresetState.hpp"
 
-#include "Renderer/StaticGlShaders.h"
+#include "Renderer/StaticGlShaders.hpp"
 
 #include <GLSLGenerator.h>
 #include <HLSLParser.h>
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.cpp b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
index d3614a19e..c52ccb423 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.cpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
@@ -2,74 +2,164 @@
 
 #include <glm/gtc/type_ptr.hpp>
 
-MotionVectors::MotionVectors()
+MotionVectors::MotionVectors(PresetState& presetState)
     : RenderItem()
+    , m_presetState(presetState)
 {
     RenderItem::Init();
 }
 
-void MotionVectors::InitVertexAttrib() {
+void MotionVectors::InitVertexAttrib()
+{
     glEnableVertexAttribArray(0);
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
     glDisableVertexAttribArray(1);
 }
 
-void MotionVectors::Draw(const RenderContext& context)
+void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext)
 {
-    // ToDo: Implement the actual Milkdop behaviour here, including reverse propagation.
-    float  intervalx=1.0/x_num;
-    float  intervaly=1.0/y_num;
+    int countX = static_cast<int>(*presetPerFrameContext.mv_x);
+    int countY = static_cast<int>(*presetPerFrameContext.mv_y);
 
+    if (countX <= 0 || countY <= 0)
+    {
+        return;
+    }
+
+    float divertX = static_cast<float>(*presetPerFrameContext.mv_x) - static_cast<float>(countX);
+    float divertY = static_cast<float>(*presetPerFrameContext.mv_y) - static_cast<float>(countY);
+
+    if (countX > 64)
+    {
+        countX = 64;
+        divertX = 0.0f;
+    }
+    if (countY > 48)
+    {
+        countY = 48;
+        divertY = 0.0f;
+    }
+
+    auto divertX2 = static_cast<float>(*presetPerFrameContext.mv_dx);
+    auto divertY2 = static_cast<float>(*presetPerFrameContext.mv_dy);
+
+    auto lengthMultiplier = static_cast<float>(*presetPerFrameContext.mv_l);
+
+    // 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;
+    }
+
+    float const inverseWidth = 1.0f / static_cast<float>(m_presetState.viewportWidth);
+    float const minimalLength = 1.0f * inverseWidth;
+
+    struct Point {
+        float x{};
+        float y{};
+    };
+
+    std::vector<Point> lineVertices(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);
 
-    if (x_num + y_num < 600)
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
+
+    glVertexAttrib4f(1,
+                     static_cast<float>(*presetPerFrameContext.mv_r),
+                     static_cast<float>(*presetPerFrameContext.mv_g),
+                     static_cast<float>(*presetPerFrameContext.mv_b),
+                     static_cast<float>(*presetPerFrameContext.mv_a));
+
+    glBindVertexArray(m_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+
+    for (int y = 0; y < countY; y++)
     {
-        int size = x_num * y_num ;
+        float const posY = (static_cast<float>(y) + 0.25f) / (static_cast<float>(countY) + divertY + 0.25f - 1.0f) - divertY2;
 
-        floatPair *points = new float[size][2];
-
-        for (int x=0;x<(int)x_num;x++)
+        if (posY > 0.0001f && posY < 0.9999f)
         {
-            for(int y=0;y<(int)y_num;y++)
+            int vertex = 0;
+            for (int x = 0; x < countX; x++)
             {
-                float lx, ly;
-                lx = x_offset+x*intervalx;
-                ly = y_offset+y*intervaly;
+                float const posX = (static_cast<float>(x) + 0.25f) / (static_cast<float>(countX) + divertX + 0.25f - 1.0f) + divertX2;
 
-                points[(x * (int)y_num) + y][0] = lx;
-                points[(x * (int)y_num) + y][1] = ly;
+                if (posX > 0.0001f && posX < 0.9999f)
+                {
+                    float posX2{};
+                    float posY2{};
+
+                    // Uses the warp mesh texture transformation to get the motion direction of this point.
+                    ReversePropagatePoint(posX, posY, posX2, posY2);
+
+                    // Enforce minimum trail length
+                    {
+                        float distX = posX2 - posX;
+                        float distY = posY2 - posY;
+
+                        distX *= lengthMultiplier;
+                        distY *= lengthMultiplier;
+
+                        float length = sqrtf(distX * distX + distY * distY);
+                        if (length > minimalLength)
+                        {
+                        }
+                        else if (length > 0.00000001f)
+                        {
+                            length = minimalLength / length;
+                            distX *= length;
+                            distY *= length;
+                        }
+                        else
+                        {
+                            distX = minimalLength;
+                            distY = minimalLength;
+                        }
+
+                        posX2 = posX + distX;
+                        posY2 = posY + distY;
+                    }
+
+                    // Assign line vertices
+                    lineVertices.at(vertex).x = posX * 2.0f - 1.0f;
+                    lineVertices.at(vertex).y = posY * 2.0f - 1.0f;
+                    lineVertices.at(vertex + 1).x = posX2 * 2.0f - 1.0f;
+                    lineVertices.at(vertex + 1).y = posY2 * 2.0f - 1.0f;
+
+                    vertex += 2;
+                }
             }
+
+            // Draw a row of lines.
+            glBufferData(GL_ARRAY_BUFFER, sizeof(Point) * lineVertices.size(), lineVertices.data(), GL_DYNAMIC_DRAW);
+            glDrawArrays(GL_LINES, 0, static_cast<GLsizei>(lineVertices.size()));
         }
-
-        glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-
-        glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair) * size, nullptr, GL_DYNAMIC_DRAW);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(floatPair) * size, points, GL_DYNAMIC_DRAW);
-
-        glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-        delete[] points;
-
-        glUseProgram(context.programID_v2f_c4f);
-
-        glUniformMatrix4fv(context.uniform_v2f_c4f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
-
-#ifndef GL_TRANSITION
-        if (length <= 0.0) {
-            glPointSize(1.0);
-        } else {
-            glPointSize(length);
-        }
-#endif
-
-        glUniform1f(context.uniform_v2f_c4f_vertex_point_size, length);
-        glVertexAttrib4f(1, r, g, b, a * masterAlpha);
-
-        glBindVertexArray(m_vaoID);
-
-        // ToDo: Milkdrop draws lines in the direction of motion, not just points!
-        glDrawArrays(GL_POINTS,0,size);
-
-        glBindVertexArray(0);
     }
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+
+    Shader::Unbind();
+
+    glDisable(GL_BLEND);
+}
+
+void MotionVectors::ReversePropagatePoint(float posX1, float posY1, float& posX2, float& posY2)
+{
 }
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.hpp b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
index 5e1416481..d8f1a736d 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.hpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "PerFrameContext.hpp"
+#include "PresetState.hpp"
+
 #include "Renderer/RenderItem.hpp"
 
 /**
@@ -14,28 +17,20 @@
 class MotionVectors : public RenderItem
 {
 public:
+    MotionVectors() = delete;
 
-    /**
-     * Constructor. Initializes the required OpenGL data structures.
-     */
-    MotionVectors();
+    explicit MotionVectors(PresetState& presetState);
 
     void InitVertexAttrib();
 
     /**
      * Redners the motion vectors.
-     * @param context The render context data.
+     * @param presetPerFrameContext The per-frame context variables.
      */
-    void Draw(const RenderContext &context);
+    void Draw(const PerFrameContext& presetPerFrameContext);
 
-    float r{ 0.0 }; //!< Red color channel of the motion vectors (mv_r).
-    float g{ 0.0 }; //!< Green color channel of the motion vectors (mv_g).
-    float b{ 0.0 }; //!< Blue color channel of the motion vectors (mv_b).
-    float a{ 0.0 }; //!< Alpha channel of the motion vectors (mv_a).
-    float length{ 0.0 }; //!< Line length of the motion vectors (mv_l).
-    float x_num{ 0.0 }; //!< Horizontal grid size (integer part of mv_x).
-    float y_num{ 0.0 }; //!< Vertical grid size (integer part of mv_y).
-    float x_offset{ 0.0 }; //!< Horizontal grid offset (mv_dx).
-    float y_offset{ 0.0 }; //!< Vertical grid offset (mv_dy).
+private:
+    void ReversePropagatePoint(float posX1, float posY1, float& posX2, float&posY2);
 
+    PresetState& m_presetState; //!< The global preset state.
 };
diff --git a/src/libprojectM/MilkdropPreset/PresetState.cpp b/src/libprojectM/MilkdropPreset/PresetState.cpp
index f78b13622..1b93f9bcb 100644
--- a/src/libprojectM/MilkdropPreset/PresetState.cpp
+++ b/src/libprojectM/MilkdropPreset/PresetState.cpp
@@ -2,9 +2,18 @@
 
 #include "PresetFileParser.hpp"
 
+#include "Renderer/StaticGlShaders.hpp"
+
+const glm::mat4 PresetState::orthogonalProjection = glm::ortho(0.0f, 1.0f, 0.0f, 1.0f, -40.0f, 40.0f);
+
 PresetState::PresetState()
     : globalMemory(projectm_eval_memory_buffer_create())
 {
+    auto staticShaders = StaticGlShaders::Get();
+    untexturedShader.CompileProgram(staticShaders->GetV2fC4fVertexShader(),
+                                      staticShaders->GetV2fC4fFragmentShader());
+    texturedShader.CompileProgram(staticShaders->GetV2fC4fT2fVertexShader(),
+                                    staticShaders->GetV2fC4fT2fFragmentShader());
 }
 
 PresetState::~PresetState()
diff --git a/src/libprojectM/MilkdropPreset/PresetState.hpp b/src/libprojectM/MilkdropPreset/PresetState.hpp
index 2abd969a0..642e9cb82 100644
--- a/src/libprojectM/MilkdropPreset/PresetState.hpp
+++ b/src/libprojectM/MilkdropPreset/PresetState.hpp
@@ -7,11 +7,15 @@
 
 #include "Constants.hpp"
 
-#include "Audio/FrameAudioData.hpp"
+#include <Audio/FrameAudioData.hpp>
+
 #include <Renderer/RenderContext.hpp>
+#include <Renderer/Shader.hpp>
 
 #include <projectm-eval.h>
 
+#include <glm/gtc/matrix_transform.hpp>
+
 #include <string>
 
 class PresetFileParser;
@@ -146,4 +150,11 @@ public:
 
     std::string warpShader; //!< Warp shader code.
     std::string compositeShader; //!< Composite shader code.
+
+    Shader untexturedShader; //!< Shader used to draw untextured primitives, e.g. waveforms.
+    Shader texturedShader; //!< Shader used to draw textured primitives, e.g. textured shapes and the warp mesh.
+
+    int mainTextureId{}; //!< ID of the previous frame texture.
+
+    static const glm::mat4 orthogonalProjection;
 };
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.cpp b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
index 9fa903c9e..7709a19d9 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.cpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
@@ -9,64 +9,80 @@
 #include "Renderer/ShaderEngine.hpp"
 #include <glm/gtc/type_ptr.hpp>
 
-VideoEcho::VideoEcho(): a(0), zoom(1), orientation(Normal)
+VideoEcho::VideoEcho(PresetState& presetState)
+    : RenderItem()
+    , m_presetState(presetState)
 {
-    Init();
+    RenderItem::Init();
 }
 
-VideoEcho::~VideoEcho()
+void VideoEcho::InitVertexAttrib()
 {
-}
-
-void VideoEcho::InitVertexAttrib() {
     glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)0);   // Positions
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, nullptr); // Positions
 
     glDisableVertexAttribArray(1);
 
     glEnableVertexAttribArray(2);
-    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float)*4, (void*)(sizeof(float)*2)); // Textures
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, reinterpret_cast<void*>(sizeof(float) * 2)); // Textures
 }
 
-void VideoEcho::Draw(RenderContext &context)
+void VideoEcho::Draw(PerFrameContext& perFrameContext)
 {
-		int flipx=1, flipy=1;
-		switch (orientation)
-		{
-			case Normal: flipx=1;flipy=1;break;
-			case FlipX: flipx=-1;flipy=1;break;
-			case FlipY: flipx=1;flipy=-1;break;
-			case FlipXY: flipx=-1;flipy=-1;break;
-			default: flipx=1;flipy=1; break;
-		}
+    int orientation = static_cast<int>(m_presetState.videoEchoOrientation) % 4;
+    int flipX;
+    int flipY;
+    switch (orientation)
+    {
+        case 0:
+            flipX = 1;
+            flipY = 1;
+            break;
+        case 1:
+            flipX = -1;
+            flipY = 1;
+            break;
+        case 2:
+            flipX = 1;
+            flipY = -1;
+            break;
+        case 3:
+            flipX = -1;
+            flipY = -1;
+            break;
+        default:
+            flipX = 1;
+            flipY = 1;
+            break;
+    }
 
     float buffer_data[8][2] = {
-        {-0.5f*flipx, -0.5f*flipy},
+        {-0.5f * flipX, -0.5f * flipY},
         {0.0, 1.0},
 
-        {-0.5f*flipx,  0.5f*flipy},
+        {-0.5f * flipX, 0.5f * flipY},
         {0.0, 0.0},
 
-        { 0.5f*flipx,  0.5f*flipy},
+        {0.5f * flipX, 0.5f * flipY},
         {1.0, 0.0},
 
-        { 0.5f*flipx, -0.5f*flipy},
-        {1.0, 1.0}
-    };
+        {0.5f * flipX, -0.5f * flipY},
+        {1.0, 1.0}};
 
     glm::mat4 mat_first_translation = glm::mat4(1.0);
     mat_first_translation[3][0] = -0.5;
     mat_first_translation[3][1] = -0.5;
 
-    glm::mat4  mat_scale = glm::mat4(1.0);
-    mat_scale[0][0] = 1.0/zoom;
-    mat_scale[1][1] = 1.0/zoom;
+    glm::mat4 mat_scale = glm::mat4(1.0);
+    mat_scale[0][0] = 1.0f / static_cast<float>(m_presetState.videoEchoZoom);
+    mat_scale[1][1] = 1.0f / static_cast<float>(m_presetState.videoEchoZoom);
 
-    glm::mat4  mat_second_translation = glm::mat4(1.0);
+    glm::mat4 mat_second_translation = glm::mat4(1.0);
     mat_second_translation[3][0] = 0.5;
     mat_second_translation[3][1] = 0.5;
 
-    for (int i = 1; i < 8; i+=2) {
+    for (int i = 1; i < 8; i += 2)
+    {
         glm::vec4 texture = glm::vec4(buffer_data[i][0], buffer_data[i][1], 0, 1);
         texture = mat_first_translation * texture;
         texture = mat_scale * texture;
@@ -84,16 +100,14 @@ void VideoEcho::Draw(RenderContext &context)
 
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 
-    glUseProgram(context.programID_v2f_c4f_t2f);
-
-    glUniformMatrix4fv(context.uniform_v2f_c4f_t2f_vertex_transformation, 1, GL_FALSE, glm::value_ptr(context.mat_ortho));
-    glUniform1i(context.uniform_v2f_c4f_t2f_frag_texture_sampler, 0);
-
+    m_presetState.texturedShader.Bind();
+    m_presetState.texturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
+    m_presetState.texturedShader.SetUniformInt("texture_sampler", 0);
 
     //Now Blend the Video Echo
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    glVertexAttrib4f(1, 1.0, 1.0, 1.0, a * masterAlpha);
+    glVertexAttrib4f(1, 1.0, 1.0, 1.0, static_cast<float>(m_presetState.videoEchoAlpha));
 
     glBindVertexArray(m_vaoID);
 
@@ -102,5 +116,5 @@ void VideoEcho::Draw(RenderContext &context)
 
     glBindVertexArray(0);
 
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.hpp b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
index 546a496cd..63b49353c 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.hpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
@@ -1,23 +1,21 @@
 #pragma once
 
-#include "projectM-opengl.h"
-#include "Renderer/RenderItem.hpp"
+#include "PerFrameContext.hpp"
+#include "PresetState.hpp"
 
-enum Orientation
-{
-	Normal=0, FlipX, FlipY, FlipXY
-};
+#include "projectM-opengl.h"
+
+#include <Renderer/RenderItem.hpp>
 
 class VideoEcho: public RenderItem
 {
 public:
-	VideoEcho();
-	virtual ~VideoEcho();
+	VideoEcho() = delete;
+    explicit VideoEcho(PresetState& presetState);
 
-	float a;
-	float zoom;
-	Orientation orientation;
+    void InitVertexAttrib() override;
 
-    void InitVertexAttrib();
-	void Draw(RenderContext &context);
+	void Draw(PerFrameContext& perFrameContext);
+private:
+    PresetState& m_presetState; //!< The global preset state.
 };
diff --git a/src/libprojectM/MilkdropPreset/Waveform.cpp b/src/libprojectM/MilkdropPreset/Waveform.cpp
index d9a8fbabf..2a08562f7 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.cpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.cpp
@@ -1,5 +1,6 @@
 #include "Waveform.hpp"
 
+#include "PerFrameContext.hpp"
 #include "PresetState.hpp"
 
 #include "Audio/BeatDetect.hpp"
@@ -13,36 +14,54 @@ Waveform::Waveform(PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
 {
-    Init();
-    SetMode();
+    RenderItem::Init();
 }
 
 Waveform::~Waveform()
 {
-    delete[] wave1Vertices;
-    delete[] wave2Vertices;
+    delete[] m_wave1Vertices;
+    delete[] m_wave2Vertices;
 }
 
 void Waveform::InitVertexAttrib()
 {
     glEnableVertexAttribArray(0);
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
     glDisableVertexAttribArray(1);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
 }
 
-void Waveform::Draw()
+void Waveform::Draw(const PerFrameContext& presetPerFrameContext)
 {
-    std::array<WaveformVertex, RenderWaveformSamples * 2> smoothedWave;
-    WaveformMath();
-
 #if USE_GLES == 0
     glDisable(GL_LINE_SMOOTH);
 #endif
     glLineWidth(1);
 
+    m_presetState.untexturedShader.Bind();
+    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", m_presetState.orthogonalProjection);
+
+    glBindVertexArray(m_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+    // Additive wave drawing (vice overwrite)
+    glEnable(GL_BLEND);
+    if (m_presetState.additiveWaves)
+    {
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+    }
+    else
+    {
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    }
+
+    WaveformMath(presetPerFrameContext);
+
+    std::vector<WaveformVertex> smoothedWave(m_samples * 2);
+
     for (int waveIndex = 0; waveIndex < 2; waveIndex++)
     {
-        auto* const waveVertices = (waveIndex == 0) ? wave1Vertices : wave2Vertices;
+        auto* const waveVertices = (waveIndex == 0) ? m_wave1Vertices : m_wave2Vertices;
         if (!waveVertices)
         {
             continue;
@@ -52,24 +71,12 @@ void Waveform::Draw()
         // Instead of using the "break" index like Milkdrop, we simply have two separate arrays.
         const auto smoothedSamples = SmoothWave(waveVertices, smoothedWave.data());
 
-        glUseProgram(m_presetState.renderContext.programID_v2f_c4f);
-
-        m_tempAlpha = m_presetState.waveAlpha;
+        m_tempAlpha = static_cast<float>(*presetPerFrameContext.wave_a);
         if (m_presetState.modWaveAlphaByvolume)
         {
-            ModulateOpacityByVolume();
-        }
-        MaximizeColors();
-
-        // Additive wave drawing (vice overwrite)
-        if (m_presetState.additiveWaves)
-        {
-            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-        }
-        else
-        {
-            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            ModulateOpacityByVolume(presetPerFrameContext);
         }
+        MaximizeColors(presetPerFrameContext);
 
         // Always draw "thick" dots.
         const auto iterations = m_presetState.waveThick || m_presetState.waveDots ? 4 : 1;
@@ -80,9 +87,6 @@ void Waveform::Draw()
 
         GLuint drawType = m_presetState.waveDots ? GL_POINTS : (m_loop ? GL_LINE_LOOP : GL_LINE_STRIP);
 
-        glBindVertexArray(m_vaoID);
-        glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
-
         // If thick outline is used, draw the shape four times with slight offsets
         // (top left, top right, bottom right, bottom left).
         for (auto iteration = 0; iteration < iterations; iteration++)
@@ -117,15 +121,17 @@ void Waveform::Draw()
             glBufferData(GL_ARRAY_BUFFER, sizeof(WaveformVertex) * smoothedSamples, smoothedWave.data(), GL_DYNAMIC_DRAW);
             glDrawArrays(drawType, 0, smoothedSamples);
         }
-
-        glBindBuffer(GL_ARRAY_BUFFER, 0);
-        glBindVertexArray(0);
     }
 
-    glUseProgram(0);
+    glDisable(GL_BLEND);
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+
+    Shader::Unbind();
 }
 
-void Waveform::ModulateOpacityByVolume()
+void Waveform::ModulateOpacityByVolume(const PerFrameContext& presetPerFrameContext)
 {
     //modulate volume by opacity
     //
@@ -138,23 +144,15 @@ void Waveform::ModulateOpacityByVolume()
     }
     else if (m_presetState.audioData.vol >= m_presetState.modWaveAlphaEnd)
     {
-        m_tempAlpha = m_presetState.waveAlpha;
+        m_tempAlpha = static_cast<float>(*presetPerFrameContext.wave_a);
     }
     else
     {
-        m_tempAlpha = m_presetState.waveAlpha * ((m_presetState.audioData.vol - m_presetState.modWaveAlphaStart) / (m_presetState.modWaveAlphaEnd - m_presetState.modWaveAlphaStart));
+        m_tempAlpha = static_cast<float>(*presetPerFrameContext.wave_a) * ((m_presetState.audioData.vol - m_presetState.modWaveAlphaStart) / (m_presetState.modWaveAlphaEnd - m_presetState.modWaveAlphaStart));
     }
 }
 
-void Waveform::SetMode()
-{
-    if (m_presetState.waveMode <= 8)
-    {
-        m_mode = static_cast<Mode>(m_presetState.waveMode);
-    }
-}
-
-void Waveform::MaximizeColors()
+void Waveform::MaximizeColors(const PerFrameContext& presetPerFrameContext)
 {
     //wave color brightening
     //
@@ -209,12 +207,12 @@ void Waveform::MaximizeColors()
         m_tempAlpha = 1.0f;
     }
 
-    if (m_presetState.maximizeWaveColor)
+    if (*presetPerFrameContext.wave_brighten)
     {
         constexpr float fMaximizeWaveColorAmount = 1.0f;
-        float cr{m_presetState.waveR};
-        float cg{m_presetState.waveG};
-        float cb{m_presetState.waveB};
+        float cr{static_cast<float>(*presetPerFrameContext.wave_r)};
+        float cg{static_cast<float>(*presetPerFrameContext.wave_g)};
+        float cb{static_cast<float>(*presetPerFrameContext.wave_b)};
 
         float max = cr;
         if (max < cg)
@@ -232,28 +230,34 @@ void Waveform::MaximizeColors()
             cb = cb / max * fMaximizeWaveColorAmount + cb * (1.0f - fMaximizeWaveColorAmount);
         }
 
-        glVertexAttrib4f(1, cr, cg, cb, m_tempAlpha * masterAlpha);
+        glVertexAttrib4f(1, cr, cg, cb, m_tempAlpha);
     }
     else
     {
-        glVertexAttrib4f(1, m_presetState.waveR, m_presetState.waveG, m_presetState.waveB, m_tempAlpha * masterAlpha);
+        glVertexAttrib4f(1,
+                         static_cast<float>(*presetPerFrameContext.wave_r),
+                         static_cast<float>(*presetPerFrameContext.wave_g),
+                         static_cast<float>(*presetPerFrameContext.wave_b),
+                         m_tempAlpha);
     }
 }
 
 
-void Waveform::WaveformMath()
+void Waveform::WaveformMath(const PerFrameContext& presetPerFrameContext)
 {
     constexpr float PI{3.14159274101257324219f};
+    constexpr size_t audioSamples{512};
 
-    delete[] wave1Vertices;
-    wave1Vertices = nullptr;
-
-    delete[] wave2Vertices;
-    wave2Vertices = nullptr;
+    delete[] m_wave1Vertices;
+    m_wave1Vertices = nullptr;
+    delete[] m_wave2Vertices;
+    m_wave2Vertices = nullptr;
 
     // NOTE: Buffer size is always 512 samples, waveform points 480 or less since some waveforms use a positive offset!
-    std::array<float, WaveformMaxPoints> pcmDataL{0.0f};
-    std::array<float, WaveformMaxPoints> pcmDataR{0.0f};
+    std::array<float, audioSamples> pcmDataL{0.0f};
+    std::array<float, audioSamples> pcmDataR{0.0f};
+
+    m_mode = static_cast<Mode>(m_presetState.waveMode % 9);
 
     if (m_mode != Mode::SpectrumLine)
     {
@@ -299,7 +303,7 @@ void Waveform::WaveformMath()
 
     m_loop = false;
 
-    float mysteryWaveParam = m_presetState.waveParam;
+    float mysteryWaveParam = static_cast<float>(*presetPerFrameContext.wave_mystery);
 
     if ((m_mode == Mode::Circle || m_mode == Mode::XYOscillationSpiral || m_mode == Mode::DerivativeLine) && (mysteryWaveParam < 1.0f || mysteryWaveParam > 1.0f))
     {
@@ -309,53 +313,56 @@ void Waveform::WaveformMath()
         mysteryWaveParam = mysteryWaveParam * 2 - 1;
     }
 
+    auto const waveX = static_cast<float>(*presetPerFrameContext.wave_x);
+    auto const waveY = static_cast<float>(*presetPerFrameContext.wave_y);
+
     switch (m_mode)
     {
 
         case Mode::Circle: {
             m_loop = true;
 
-            int const samples = RenderWaveformSamples / 2;
+            m_samples = RenderWaveformSamples / 2;
 
-            wave1Vertices = new WaveformVertex[samples]();
+            m_wave1Vertices = new WaveformVertex[m_samples]();
 
-            const int sampleOffset{(RenderWaveformSamples - samples) / 2};
+            const int sampleOffset{(RenderWaveformSamples - m_samples) / 2};
 
-            const float inverseSamplesMinusOne{1.0f / static_cast<float>(samples)};
+            const float inverseSamplesMinusOne{1.0f / static_cast<float>(m_samples)};
 
-            for (int i = 0; i < samples; i++)
+            for (int i = 0; i < m_samples; i++)
             {
                 float radius = 0.5f + 0.4f * pcmDataR[i + sampleOffset] + mysteryWaveParam;
                 float const angle = static_cast<float>(i) * inverseSamplesMinusOne * 6.28f + m_presetState.renderContext.time * 0.2f;
-                if (i < samples / 10)
+                if (i < m_samples / 10)
                 {
-                    float mix = static_cast<float>(i) / (static_cast<float>(samples) * 0.1f);
+                    float mix = static_cast<float>(i) / (static_cast<float>(m_samples) * 0.1f);
                     mix = 0.5f - 0.5f * cosf(mix * 3.1416f);
-                    float const radius2 = 0.5f + 0.4f * pcmDataR[i + samples + sampleOffset] + mysteryWaveParam;
+                    float const radius2 = 0.5f + 0.4f * pcmDataR[i + m_samples + sampleOffset] + mysteryWaveParam;
                     radius = radius2 * (1.0f - mix) + radius * (mix);
                 }
 
                 radius *= 0.5f;
 
-                wave1Vertices[i].x = radius * cosf(angle) * aspectY + m_presetState.waveX;
-                wave1Vertices[i].y = radius * sinf(angle) * aspectX + m_presetState.waveY;
+                m_wave1Vertices[i].x = radius * cosf(angle) * aspectY + waveX;
+                m_wave1Vertices[i].y = radius * sinf(angle) * aspectX + waveY;
             }
             break;
         }
 
         case Mode::XYOscillationSpiral: //circularly moving waveform
         {
-            int const samples = RenderWaveformSamples / 2;
+            m_samples = RenderWaveformSamples / 2;
 
-            wave1Vertices = new WaveformVertex[samples]();
+            m_wave1Vertices = new WaveformVertex[m_samples]();
 
-            for (int i = 0; i < samples; i++)
+            for (int i = 0; i < m_samples; i++)
             {
                 float const radius = (0.53f + 0.43f * pcmDataR[i] + mysteryWaveParam) * 0.5f;
                 float const angle = pcmDataL[i + 32] * PI * 0.5f + m_presetState.renderContext.time * 2.3f;
 
-                wave1Vertices[i].x = radius * cosf(angle) * aspectY + m_presetState.waveX;
-                wave1Vertices[i].y = radius * sinf(angle) * aspectX + m_presetState.waveY;
+                m_wave1Vertices[i].x = radius * cosf(angle) * aspectY + waveX;
+                m_wave1Vertices[i].y = radius * sinf(angle) * aspectX + waveY;
             }
             break;
         }
@@ -363,69 +370,69 @@ void Waveform::WaveformMath()
         case Mode::Blob2:
         case Mode::Blob3: { // Both "centered spiro" waveforms are identical. Only difference is the alpha value.
             // Alpha calculation is handled in MaximizeColors().
-            int const samples = RenderWaveformSamples;
+            m_samples = RenderWaveformSamples;
 
-            wave1Vertices = new WaveformVertex[samples]();
+            m_wave1Vertices = new WaveformVertex[m_samples]();
 
-            for (int i = 0; i < samples; i++)
+            for (int i = 0; i < m_samples; i++)
             {
-                wave1Vertices[i].x = 0.5f * pcmDataR[i] * aspectY + m_presetState.waveX;
-                wave1Vertices[i].y = 0.5f * pcmDataL[i + 32] * aspectX + m_presetState.waveY;
+                m_wave1Vertices[i].x = 0.5f * pcmDataR[i] * aspectY + waveX;
+                m_wave1Vertices[i].y = 0.5f * pcmDataL[i + 32] * aspectX + waveY;
             }
 
             break;
         }
 
         case Mode::DerivativeLine: {
-            int samples = RenderWaveformSamples;
+            m_samples = RenderWaveformSamples;
 
-            if (samples > m_presetState.renderContext.viewportSizeX / 3)
+            if (m_samples > m_presetState.renderContext.viewportSizeX / 3)
             {
-                samples /= 3;
+                m_samples /= 3;
             }
 
-            wave1Vertices = new WaveformVertex[samples]();
+            m_wave1Vertices = new WaveformVertex[m_samples]();
 
-            int const sampleOffset = (RenderWaveformSamples - samples) / 2;
+            int const sampleOffset = (RenderWaveformSamples - m_samples) / 2;
 
             const float w1 = 0.45f + 0.5f * (mysteryWaveParam * 0.5f + 0.5f);
             const float w2 = 1.0f - w1;
 
-            const float inverseSamples = 1.0f / static_cast<float>(samples);
+            const float inverseSamples = 1.0f / static_cast<float>(m_samples);
 
-            for (int i = 0; i < samples; i++)
+            for (int i = 0; i < m_samples; i++)
             {
                 assert((i + 25 + sampleOffset) < 512);
-                wave1Vertices[i].x = (-1.0f + 2.0f * (i * inverseSamples)) * 0.5f + m_presetState.waveX;
-                wave1Vertices[i].y = pcmDataL[i + sampleOffset] * 0.235f + m_presetState.waveY;
-                wave1Vertices[i].x += pcmDataR[i + 25 + sampleOffset] * 0.22f;
+                m_wave1Vertices[i].x = (-1.0f + 2.0f * (i * inverseSamples)) * 0.5f + waveX;
+                m_wave1Vertices[i].y = pcmDataL[i + sampleOffset] * 0.235f + waveY;
+                m_wave1Vertices[i].x += pcmDataR[i + 25 + sampleOffset] * 0.22f;
 
                 // Momentum
                 if (i > 1)
                 {
-                    wave1Vertices[i].x =
-                        wave1Vertices[i].x * w2 + w1 * (wave1Vertices[i - 1].x * 2.0f - wave1Vertices[i - 2].x);
-                    wave1Vertices[i].y =
-                        wave1Vertices[i].y * w2 + w1 * (wave1Vertices[i - 1].y * 2.0f - wave1Vertices[i - 2].y);
+                    m_wave1Vertices[i].x =
+                        m_wave1Vertices[i].x * w2 + w1 * (m_wave1Vertices[i - 1].x * 2.0f - m_wave1Vertices[i - 2].x);
+                    m_wave1Vertices[i].y =
+                        m_wave1Vertices[i].y * w2 + w1 * (m_wave1Vertices[i - 1].y * 2.0f - m_wave1Vertices[i - 2].y);
                 }
             }
             break;
         }
 
         case Mode::ExplosiveHash: {
-            int const samples = RenderWaveformSamples;
+            m_samples = RenderWaveformSamples;
 
-            wave1Vertices = new WaveformVertex[samples]();
+            m_wave1Vertices = new WaveformVertex[m_samples]();
 
             const float cosineRotation = cosf(m_presetState.renderContext.time * 0.3f);
             const float sineRotation = sinf(m_presetState.renderContext.time * 0.3f);
 
-            for (int i = 0; i < samples; i++)
+            for (int i = 0; i < m_samples; i++)
             {
                 const float x0 = (pcmDataR[i] * pcmDataL[i + 32] + pcmDataL[i] * pcmDataR[i + 32]);
                 const float y0 = (pcmDataR[i] * pcmDataR[i] - pcmDataL[i + 32] * pcmDataL[i + 32]);
-                wave1Vertices[i].x = ((x0 * cosineRotation - y0 * sineRotation) * 0.5f * aspectY) + m_presetState.waveX;
-                wave1Vertices[i].y = ((x0 * sineRotation + y0 * cosineRotation) * 0.5f * aspectX) + m_presetState.waveY;
+                m_wave1Vertices[i].x = ((x0 * cosineRotation - y0 * sineRotation) * 0.5f * aspectY) + waveX;
+                m_wave1Vertices[i].y = ((x0 * sineRotation + y0 * cosineRotation) * 0.5f * aspectX) + waveY;
             }
             break;
         }
@@ -434,40 +441,39 @@ void Waveform::WaveformMath()
         case Mode::DoubleLine:
         case Mode::SpectrumLine: // Unfinished
         {
-            int samples;
             if (m_mode == Mode::SpectrumLine)
             {
-                samples = 256;
+                m_samples = 256;
             }
             else
             {
-                samples = RenderWaveformSamples / 2;
+                m_samples = RenderWaveformSamples / 2;
 
-                if (samples > m_presetState.renderContext.viewportSizeX / 3)
+                if (m_samples > m_presetState.viewportWidth / 3)
                 {
-                    samples /= 3;
+                    m_samples /= 3;
                 }
             }
 
-            wave1Vertices = new WaveformVertex[samples]();
+            m_wave1Vertices = new WaveformVertex[m_samples]();
             if (m_mode == Mode::DoubleLine)
             {
-                wave2Vertices = new WaveformVertex[samples]();
+                m_wave2Vertices = new WaveformVertex[m_samples]();
             }
 
-            const int sampleOffset = (RenderWaveformSamples - samples) / 2;
+            const int sampleOffset = (RenderWaveformSamples - m_samples) / 2;
 
             const float angle = PI * 0.5f * mysteryWaveParam; // from -PI/2 to PI/2
             float dx = cosf(angle);
             float dy = sinf(angle);
 
             std::array<float, 2> edgeX{
-                m_presetState.waveX * cosf(angle + PI * 0.5f) - dx * 3.0f,
-                m_presetState.waveX * cosf(angle + PI * 0.5f) + dx * 3.0f};
+                waveX * cosf(angle + PI * 0.5f) - dx * 3.0f,
+                waveX * cosf(angle + PI * 0.5f) + dx * 3.0f};
 
             std::array<float, 2> edgeY{
-                m_presetState.waveX * sinf(angle + PI * 0.5f) - dy * 3.0f,
-                m_presetState.waveX * sinf(angle + PI * 0.5f) + dy * 3.0f};
+                waveX * sinf(angle + PI * 0.5f) - dy * 3.0f,
+                waveX * sinf(angle + PI * 0.5f) + dy * 3.0f};
 
             for (int i = 0; i < 2; i++)
             {
@@ -521,8 +527,8 @@ void Waveform::WaveformMath()
                 }
             }
 
-            dx = (edgeX[1] - edgeX[0]) / static_cast<float>(samples);
-            dy = (edgeY[1] - edgeY[0]) / static_cast<float>(samples);
+            dx = (edgeX[1] - edgeX[0]) / static_cast<float>(m_samples);
+            dy = (edgeY[1] - edgeY[0]) / static_cast<float>(m_samples);
 
             const float angle2 = atan2f(dy, dx);
             const float perpetualDX = cosf(angle2 + PI * 0.5f);
@@ -530,37 +536,37 @@ void Waveform::WaveformMath()
 
             if (m_mode == Mode::Line)
             {
-                for (int i = 0; i < samples; i++)
+                for (int i = 0; i < m_samples; i++)
                 {
-                    wave1Vertices[i].x =
+                    m_wave1Vertices[i].x =
                         edgeX[0] + dx * static_cast<float>(i) + perpetualDX * 0.25f * pcmDataL[i + sampleOffset];
-                    wave1Vertices[i].y =
+                    m_wave1Vertices[i].y =
                         edgeY[0] + dy * static_cast<float>(i) + perpetualDY * 0.25f * pcmDataL[i + sampleOffset];
                 }
             }
             else if (m_mode == Mode::SpectrumLine)
             {
-                for (int i = 0; i < samples; i++)
+                for (int i = 0; i < m_samples; i++)
                 {
                     const float f = 0.1f * logf(pcmDataL[i * 2] + pcmDataL[i * 2 + 1]);
-                    wave1Vertices[i].x = edgeX[0] + dx * static_cast<float>(i) + perpetualDX * f;
-                    wave1Vertices[i].y = edgeY[0] + dy * static_cast<float>(i) + perpetualDY * f;
+                    m_wave1Vertices[i].x = edgeX[0] + dx * static_cast<float>(i) + perpetualDX * f;
+                    m_wave1Vertices[i].y = edgeY[0] + dy * static_cast<float>(i) + perpetualDY * f;
                 }
             }
             else
             {
-                float const separation = powf(m_presetState.waveY * 0.25f + 0.25f, 2.0f);
-                for (int i = 0; i < samples; i++)
+                float const separation = powf(waveY * 0.25f + 0.25f, 2.0f);
+                for (int i = 0; i < m_samples; i++)
                 {
-                    wave1Vertices[i].x = edgeX[0] + dx * static_cast<float>(i) +
-                                         perpetualDX * (0.25f * pcmDataL[i + sampleOffset] + separation);
-                    wave1Vertices[i].y = edgeY[0] + dy * static_cast<float>(i) +
-                                         perpetualDY * (0.25f * pcmDataL[i + sampleOffset] + separation);
+                    m_wave1Vertices[i].x = edgeX[0] + dx * static_cast<float>(i) +
+                                           perpetualDX * (0.25f * pcmDataL[i + sampleOffset] + separation);
+                    m_wave1Vertices[i].y = edgeY[0] + dy * static_cast<float>(i) +
+                                           perpetualDY * (0.25f * pcmDataL[i + sampleOffset] + separation);
 
-                    wave2Vertices[i].x = edgeX[0] + dx * static_cast<float>(i) +
-                                         perpetualDX * (0.25f * pcmDataR[i + sampleOffset] - separation);
-                    wave2Vertices[i].y = edgeY[0] + dy * static_cast<float>(i) +
-                                         perpetualDY * (0.25f * pcmDataR[i + sampleOffset] - separation);
+                    m_wave2Vertices[i].x = edgeX[0] + dx * static_cast<float>(i) +
+                                           perpetualDX * (0.25f * pcmDataR[i + sampleOffset] - separation);
+                    m_wave2Vertices[i].y = edgeY[0] + dy * static_cast<float>(i) +
+                                           perpetualDY * (0.25f * pcmDataR[i + sampleOffset] - separation);
                 }
             }
             break;
@@ -571,15 +577,15 @@ void Waveform::WaveformMath()
     }
 
     // Reverse all Y coordinates to stay consistent with the pre-VMS milkdrop
-    for (int i = 0; i < RenderWaveformSamples; i++)
+    for (int i = 0; i < m_samples; i++)
     {
-        if (wave1Vertices)
+        if (m_wave1Vertices)
         {
-            wave1Vertices[i].y = 1.0f - wave1Vertices[i].y;
+            m_wave1Vertices[i].y = 1.0f - m_wave1Vertices[i].y;
         }
-        if (wave2Vertices)
+        if (m_wave2Vertices)
         {
-            wave2Vertices[i].y = 1.0f - wave2Vertices[i].y;
+            m_wave2Vertices[i].y = 1.0f - m_wave2Vertices[i].y;
         }
     }
 }
@@ -597,10 +603,10 @@ int Waveform::SmoothWave(const Waveform::WaveformVertex* inputVertices,
     int indexBelow = 0;
     int indexAbove2 = 1;
 
-    for (auto inputIndex = 0; inputIndex < RenderWaveformSamples - 1; inputIndex++)
+    for (auto inputIndex = 0; inputIndex < m_samples - 1; inputIndex++)
     {
         int const indexAbove = indexAbove2;
-        indexAbove2 = std::min(RenderWaveformSamples - 1, inputIndex + 2);
+        indexAbove2 = std::min(m_samples - 1, inputIndex + 2);
         outputVertices[outputIndex] = inputVertices[inputIndex];
         outputVertices[outputIndex + 1].x = (c1 * inputVertices[indexBelow].x + c2 * inputVertices[inputIndex].x + c3 * inputVertices[indexAbove].x + c4 * inputVertices[indexAbove2].x) * inverseSum;
         outputVertices[outputIndex + 1].y = (c1 * inputVertices[indexBelow].y + c2 * inputVertices[inputIndex].y + c3 * inputVertices[indexAbove].y + c4 * inputVertices[indexAbove2].y) * inverseSum;
@@ -608,7 +614,7 @@ int Waveform::SmoothWave(const Waveform::WaveformVertex* inputVertices,
         outputIndex += 2;
     }
 
-    outputVertices[outputIndex] = inputVertices[RenderWaveformSamples - 1];
+    outputVertices[outputIndex] = inputVertices[m_samples - 1];
 
     return outputIndex + 1;
 }
diff --git a/src/libprojectM/MilkdropPreset/Waveform.hpp b/src/libprojectM/MilkdropPreset/Waveform.hpp
index 55f0c2735..98bd9f53e 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.hpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.hpp
@@ -27,7 +27,7 @@ public:
     Waveform(PresetState& presetState);
     ~Waveform() override;
 
-    void Draw();
+    void Draw(const PerFrameContext& presetPerFrameContext);
 
     void InitVertexAttrib() override;
 
@@ -40,9 +40,9 @@ private:
 
     void SetMode();
 
-    void MaximizeColors();
-    void ModulateOpacityByVolume();
-    void WaveformMath();
+    void MaximizeColors(const PerFrameContext& presetPerFrameContext);
+    void ModulateOpacityByVolume(const PerFrameContext& presetPerFrameContext);
+    void WaveformMath(const PerFrameContext& presetPerFrameContext);
 
     /**
      * @brief Does a better-than-linear smooth on a wave.
@@ -50,19 +50,19 @@ private:
      * Roughly doubles the number of points.
      *
      * @param inputVertices Pointer to an array of vertices to be smoothed.
-     * @param vertexCount Number of vertices/points in the input data.
      * @param outputVertices Pointer to a buffer that will receive the smoothed data. Must be able to hold 2 * vertexCount vertices.
      * @return The number of vertices in outputVertices after smoothing.
      */
-    static auto SmoothWave(const WaveformVertex* inputVertices, WaveformVertex* outputVertices) -> int;
+    auto SmoothWave(const WaveformVertex* inputVertices, WaveformVertex* outputVertices) -> int;
 
-    PresetState& m_presetState;
+    PresetState& m_presetState; //!< The preset state.
 
-    Mode m_mode{Mode::Line};
+    Mode m_mode{Mode::Line}; //!< Line drawing mode.
 
-    float m_tempAlpha{0.0f};
-    bool m_loop{false};
+    float m_tempAlpha{0.0f}; //!< Calculated alpha value.
+    bool m_loop{false}; //!< true if the waveform is a closed loop.
+    int m_samples{}; //!< Number of samples in the current waveform. Depends on the mode.
 
-    WaveformVertex* wave1Vertices{nullptr};
-    WaveformVertex* wave2Vertices{nullptr};
+    WaveformVertex* m_wave1Vertices{nullptr};
+    WaveformVertex* m_wave2Vertices{nullptr};
 };
diff --git a/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp b/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp
index 56a5467e6..146cde6bb 100644
--- a/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp
+++ b/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp
@@ -42,7 +42,7 @@ void WaveformPerPointContext::RegisterBuiltinVariables()
     for (int t = 0; t < TVarCount; t++)
     {
         std::string tvar = "t" + std::to_string(t + 1);
-        q_vars[t] = projectm_eval_context_register_variable(perPointCodeContext, tvar.c_str());
+        t_vars[t] = projectm_eval_context_register_variable(perPointCodeContext, tvar.c_str());
     }
 
     REG_VAR(bass);
diff --git a/src/libprojectM/ProjectM.cpp b/src/libprojectM/ProjectM.cpp
index 62610cd4e..d6a410b92 100644
--- a/src/libprojectM/ProjectM.cpp
+++ b/src/libprojectM/ProjectM.cpp
@@ -98,12 +98,14 @@ void ProjectM::LoadPresetData(std::istream& presetData, bool smoothTransition)
 void ProjectM::SetTexturePaths(std::vector<std::string> texturePaths)
 {
     m_textureSearchPaths = std::move(texturePaths);
-    m_renderer->SetTextureSearchPaths(m_textureSearchPaths);
+    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
+    //m_renderer->SetTextureSearchPaths(m_textureSearchPaths);
 }
 
 void ProjectM::ResetTextures()
 {
-    m_renderer->ResetTextures();
+    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
+    //m_renderer->ResetTextures();
 }
 
 void ProjectM::DumpDebugImageOnNextFrame(const std::string& outputFile)
@@ -179,6 +181,23 @@ void ProjectM::RenderFrame()
     }
 
     // ToDo: Call the to-be-implemented render method in Renderer
+    auto audio = m_beatDetect->GetFrameAudioData();
+
+    RenderContext ctx{};
+    ctx.viewportSizeX = m_windowWidth;
+    ctx.viewportSizeY = m_windowHeight;
+    ctx.time = m_timeKeeper->GetRunningTime();
+    ctx.progress = m_timeKeeper->PresetProgressA();
+    ctx.fps = m_targetFps;
+    ctx.frame = m_count;
+    ctx.aspectX = (m_windowHeight > m_windowWidth) ? static_cast<float>(m_windowWidth) / static_cast<float>(m_windowHeight) : 1.0f;
+    ctx.aspectY = (m_windowWidth > m_windowHeight) ? static_cast<float>(m_windowHeight) / static_cast<float>(m_windowWidth) : 1.0f;
+    ctx.invAspectX = 1.0f / ctx.aspectX;
+    ctx.invAspectY = 1.0f / ctx.aspectY;
+
+    m_activePreset->RenderFrame(audio, ctx);
+
+    m_count++;
 }
 
 void ProjectM::Reset()
@@ -213,6 +232,8 @@ void ProjectM::Initialize()
                                                   *m_beatDetect,
                                                   m_textureSearchPaths);
 
+    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
+
     m_presetFactoryManager->initialize();
 
     /* Set the seed to the current time in seconds */
diff --git a/src/libprojectM/ProjectM.hpp b/src/libprojectM/ProjectM.hpp
index d06cee3ad..a80fca790 100644
--- a/src/libprojectM/ProjectM.hpp
+++ b/src/libprojectM/ProjectM.hpp
@@ -60,6 +60,8 @@ class Func;
 
 class Renderer;
 
+class TextureManager;
+
 class Preset;
 
 class TimeKeeper;
@@ -256,6 +258,7 @@ private:
     std::unique_ptr<PresetFactoryManager> m_presetFactoryManager; //!< Provides access to all available preset factories.
 
     std::unique_ptr<Renderer> m_renderer;                         //!< The Preset renderer.
+    std::unique_ptr<TextureManager> m_textureManager;             //!< The texture manager.
     std::unique_ptr<libprojectM::Audio::BeatDetect> m_beatDetect; //!< The beat detection class.
     std::unique_ptr<Preset> m_activePreset;                       //!< Currently loaded preset.
     std::unique_ptr<Preset> m_transitioningPreset;                //!< Destination preset when smooth preset switching.
diff --git a/src/libprojectM/Renderer/Framebuffer.cpp b/src/libprojectM/Renderer/Framebuffer.cpp
index b50312cf4..bf8f0f09b 100644
--- a/src/libprojectM/Renderer/Framebuffer.cpp
+++ b/src/libprojectM/Renderer/Framebuffer.cpp
@@ -106,6 +106,22 @@ void Framebuffer::CreateColorAttachment(int framebufferIndex, int attachmentInde
     }
 }
 
+GLuint Framebuffer::GetColorAttachmentTexture(int framebufferIndex, int attachmentIndex) const
+{
+    if (framebufferIndex < 0 || framebufferIndex >= static_cast<int>(m_framebufferIds.size()))
+    {
+        return 0;
+    }
+
+    const auto& attachment = m_attachments.at(framebufferIndex);
+    if (attachment.find(GL_COLOR_ATTACHMENT0 + attachmentIndex) == attachment.end())
+    {
+        return 0;
+    }
+
+    return attachment.at(GL_COLOR_ATTACHMENT0 + attachmentIndex).TextureId();
+}
+
 void Framebuffer::CreateDepthAttachment(int framebufferIndex)
 {
     if (framebufferIndex < 0 || framebufferIndex >= static_cast<int>(m_framebufferIds.size()))
diff --git a/src/libprojectM/Renderer/Framebuffer.hpp b/src/libprojectM/Renderer/Framebuffer.hpp
index 0ffccb4b5..904f8415b 100644
--- a/src/libprojectM/Renderer/Framebuffer.hpp
+++ b/src/libprojectM/Renderer/Framebuffer.hpp
@@ -77,22 +77,34 @@ public:
     /**
      * @brief Adds a new color attachment to the framebuffer.
      * The texture is always created in RGBA format.
+     * @param framebufferIndex The framebuffer index.
      * @param index The index of the attachment, at least indices 0-7 are guaranteed to be available.
      */
     void CreateColorAttachment(int framebufferIndex, int attachmentIndex);
 
+    /**
+     * @brief Returns the texture ID of the given framebuffer and color attachment.
+     * @param framebufferIndex The framebuffer index.
+     * @param attachmentIndex The index of the attachment to return the texture for.
+     * @return The texture ID or 0 if no texture is assigned.
+     */
+    auto GetColorAttachmentTexture(int framebufferIndex, int attachmentIndex) const -> GLuint;
+
     /**
      * @brief Adds a depth attachment to the framebuffer.
+     * @param framebufferIndex The framebuffer index.
      */
     void CreateDepthAttachment(int framebufferIndex);
 
     /**
      * @brief Adds a stencil buffer attachment to the framebuffer.
+     * @param framebufferIndex The framebuffer index.
      */
     void CreateStencilAttachment(int framebufferIndex);
 
     /**
      * @brief Adds a depth stencil buffer attachment to the framebuffer.
+     * @param framebufferIndex The framebuffer index.
      */
     void CreateDepthStencilAttachment(int framebufferIndex);
 
diff --git a/src/libprojectM/Renderer/RenderContext.hpp b/src/libprojectM/Renderer/RenderContext.hpp
index 09ca98052..c6af3956e 100644
--- a/src/libprojectM/Renderer/RenderContext.hpp
+++ b/src/libprojectM/Renderer/RenderContext.hpp
@@ -26,11 +26,5 @@ public:
 
     TextureManager* textureManager{nullptr};            //!< Holds all loaded textures for shader access.
 
-    GLuint programID_v2f_c4f{0};                        //!< Vertex shader program ID (no texture coordinates)
-    GLuint programID_v2f_c4f_t2f{0};                    //!< Vertex shader program ID (with texture coordinates)
-    GLint uniform_v2f_c4f_vertex_transformation{0};     //!< Uniform location of the vertex shader transformation parameter (untextured output)
-    GLint uniform_v2f_c4f_vertex_point_size{0};         //!< Uniform location of the vertex shader point size parameter (untextured output)
-    GLint uniform_v2f_c4f_t2f_vertex_transformation{0}; //!< Uniform location of the vertex shader transformation parameter (textured output)
-    GLint uniform_v2f_c4f_t2f_frag_texture_sampler{0};  //!< Uniform location of the vertex shader transformation parameter (textured output)
     glm::mat4 mat_ortho{0.0};                           //!< Orthographic projection matrix.
 };
diff --git a/src/libprojectM/Renderer/Renderer.cpp b/src/libprojectM/Renderer/Renderer.cpp
index e4f887e82..70b6e0616 100644
--- a/src/libprojectM/Renderer/Renderer.cpp
+++ b/src/libprojectM/Renderer/Renderer.cpp
@@ -109,7 +109,7 @@ Renderer::Renderer(int viewportWidth, int viewportHeight, int meshX, int meshY,
 
 void Renderer::ResetTextures()
 {
-    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths, m_mainTextureSizeX, m_mainTextureSizeY);
+    //m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
 }
 
 void Renderer::SetTextureSearchPaths(std::vector<std::string>& textureSearchPaths)
diff --git a/src/libprojectM/Renderer/ShaderEngine.cpp b/src/libprojectM/Renderer/ShaderEngine.cpp
index 057add7ff..1c129daae 100644
--- a/src/libprojectM/Renderer/ShaderEngine.cpp
+++ b/src/libprojectM/Renderer/ShaderEngine.cpp
@@ -1,6 +1,6 @@
 #include "ShaderEngine.hpp"
 
-#include "StaticGlShaders.h"
+#include "StaticGlShaders.hpp"
 #include "Texture.hpp"
 #include <glm/gtc/type_ptr.hpp>
 
diff --git a/src/libprojectM/Renderer/StaticGlShaders.cpp b/src/libprojectM/Renderer/StaticGlShaders.cpp
index 971eab7cf..26b9126b4 100644
--- a/src/libprojectM/Renderer/StaticGlShaders.cpp
+++ b/src/libprojectM/Renderer/StaticGlShaders.cpp
@@ -1,4 +1,4 @@
-#include "StaticGlShaders.h"
+#include "StaticGlShaders.hpp"
 
 #include "projectM-opengl.h"
 
diff --git a/src/libprojectM/Renderer/StaticGlShaders.h b/src/libprojectM/Renderer/StaticGlShaders.hpp
similarity index 100%
rename from src/libprojectM/Renderer/StaticGlShaders.h
rename to src/libprojectM/Renderer/StaticGlShaders.hpp
diff --git a/src/libprojectM/Renderer/TextureManager.cpp b/src/libprojectM/Renderer/TextureManager.cpp
index b8b46ac1c..a064b1399 100644
--- a/src/libprojectM/Renderer/TextureManager.cpp
+++ b/src/libprojectM/Renderer/TextureManager.cpp
@@ -15,10 +15,8 @@
 #define GL_TEXTURE_IMAGE_FORMAT 0x828F
 #endif
 
-#define NUM_BLUR_TEX    6
 
-
-TextureManager::TextureManager(std::vector<std::string>& textureSearchPaths, int texSizeX, int texSizeY)
+TextureManager::TextureManager(std::vector<std::string>& textureSearchPaths)
     : m_textureDirectories(textureSearchPaths)
 {
     FileScanner fileScanner = FileScanner(m_textureDirectories, m_extensions);
@@ -29,41 +27,6 @@ TextureManager::TextureManager(std::vector<std::string>& textureSearchPaths, int
 
     Preload();
 
-    // Create main texture and associated samplers
-    m_mainTexture = new Texture("main", texSizeX, texSizeY, false);
-    m_mainTexture->getSampler(GL_REPEAT, GL_LINEAR);
-    m_mainTexture->getSampler(GL_REPEAT, GL_NEAREST);
-    m_mainTexture->getSampler(GL_CLAMP_TO_EDGE, GL_LINEAR);
-    m_mainTexture->getSampler(GL_CLAMP_TO_EDGE, GL_NEAREST);
-    m_textures["main"] = m_mainTexture;
-
-    // Initialize blur textures
-    int w = texSizeX;
-    int h = texSizeY;
-    for (int i=0; i<NUM_BLUR_TEX; i++)
-    {
-        // main VS = 1024
-        // blur0 = 512
-        // blur1 = 256  <-  user sees this as "blur1"
-        // blur2 = 128
-        // blur3 = 128  <-  user sees this as "blur2"
-        // blur4 =  64
-        // blur5 =  64  <-  user sees this as "blur3"
-        if (!(i&1) || (i<2))
-        {
-			w = std::max(16, w / 2);
-			h = std::max(16, h / 2);
-        }
-        int w2 = ((w+3)/16)*16;
-        int h2 = ((h+3)/4)*4;
-
-        std::string texname = "blur" + std::to_string(i/2+1) + ((i%2) ? "" : "doNOTuseME");
-        Texture * textureBlur = new Texture(texname, w2, h2, false);
-        textureBlur->getSampler(GL_CLAMP_TO_EDGE, GL_LINEAR);
-        m_textures[texname] = textureBlur;
-        m_blurTextures.push_back(textureBlur);
-    }
-
     auto noise = std::make_unique<MilkdropNoise>();
 
 #if !USE_GLES
@@ -388,19 +351,3 @@ void TextureManager::ExtractTextureSettings(const std::string qualifiedName, GLi
         name = qualifiedName;
     }
 }
-
-const Texture * TextureManager::getMainTexture() const {
-    return m_mainTexture;
-}
-
-const std::vector<Texture*> & TextureManager::getBlurTextures() const {
-    return m_blurTextures;
-}
-
-
-void TextureManager::updateMainTexture()
-{
-    glBindTexture(GL_TEXTURE_2D, m_mainTexture->texID);
-    glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, m_mainTexture->width, m_mainTexture->height);
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
diff --git a/src/libprojectM/Renderer/TextureManager.hpp b/src/libprojectM/Renderer/TextureManager.hpp
index a4e57af76..3fbff0af8 100644
--- a/src/libprojectM/Renderer/TextureManager.hpp
+++ b/src/libprojectM/Renderer/TextureManager.hpp
@@ -15,17 +15,12 @@ public:
     /**
      * Constructor.
      * @param textureSearchPaths List of paths to search for textures. These paths are search in the given order.
-     * @param texSizeX Width of the main texture. Does not influence the size of loaded textures!
-     * @param texSizeY Height of the main texture. Does not influence the size of loaded textures!
      */
-    TextureManager(std::vector<std::string>& textureSearchPaths, int texSizeX, int texSizeY);
+    TextureManager(std::vector<std::string>& textureSearchPaths);
     ~TextureManager();
 
     TextureSamplerDesc tryLoadingTexture(const std::string name);
     TextureSamplerDesc getTexture(const std::string fullName, const GLenum defaultWrap, const GLenum defaultFilter);
-    const Texture* getMainTexture() const;
-    const std::vector<Texture*>& getBlurTextures() const;
-    void updateMainTexture();
     TextureSamplerDesc getRandomTextureName(std::string rand_name);
     void clearRandomTextures();
 
@@ -38,8 +33,6 @@ private:
 
     std::vector<std::string>& m_textureDirectories;
     std::map<std::string, Texture*> m_textures;
-    std::vector<Texture*> m_blurTextures;
-    Texture* m_mainTexture;
     std::vector<std::string> m_randomTextures;
     std::vector<std::string> m_extensions{".jpg", ".jpeg", ".dds", ".png", ".tga", ".bmp", ".dib"};
 };