From 9762297909a41a93c5695f9adee6f00c14bb361a Mon Sep 17 00:00:00 2001
From: Kai Blaschke <kai.blaschke@kb-dev.net>
Date: Fri, 29 Dec 2023 17:40:02 +0100
Subject: [PATCH] Properly namespace all classes under "::libprojectM"

---
 src/libprojectM/BackgroundWorker.hpp          |  4 +
 .../MilkdropPreset/BlurTexture.cpp            | 28 ++++---
 .../MilkdropPreset/BlurTexture.hpp            | 28 ++++---
 src/libprojectM/MilkdropPreset/Border.cpp     |  8 +-
 src/libprojectM/MilkdropPreset/Border.hpp     |  9 ++-
 src/libprojectM/MilkdropPreset/CMakeLists.txt |  4 +-
 src/libprojectM/MilkdropPreset/Constants.hpp  |  6 ++
 .../MilkdropPreset/CustomShape.cpp            | 10 ++-
 .../MilkdropPreset/CustomShape.hpp            |  8 +-
 .../MilkdropPreset/CustomWaveform.cpp         |  8 +-
 .../MilkdropPreset/CustomWaveform.hpp         |  8 +-
 .../MilkdropPreset/DarkenCenter.cpp           |  8 +-
 .../MilkdropPreset/DarkenCenter.hpp           |  8 +-
 ...{MilkdropPresetFactory.cpp => Factory.cpp} | 15 ++--
 ...{MilkdropPresetFactory.hpp => Factory.hpp} |  8 +-
 src/libprojectM/MilkdropPreset/Filters.cpp    |  8 +-
 src/libprojectM/MilkdropPreset/Filters.hpp    |  8 +-
 .../MilkdropPreset/FinalComposite.cpp         | 12 ++-
 .../MilkdropPreset/FinalComposite.hpp         |  8 +-
 src/libprojectM/MilkdropPreset/IdlePreset.cpp |  7 +-
 src/libprojectM/MilkdropPreset/IdlePreset.hpp | 11 ++-
 .../MilkdropPreset/MilkdropPreset.cpp         | 22 ++++--
 .../MilkdropPreset/MilkdropPreset.hpp         | 28 ++++---
 .../MilkdropPresetExceptions.hpp              |  6 ++
 .../MilkdropPreset/MilkdropShader.cpp         | 41 +++++-----
 .../MilkdropPreset/MilkdropShader.hpp         | 14 +++-
 .../MilkdropStaticShaders.cpp.in              |  2 +-
 .../MilkdropStaticShaders.hpp.in              |  6 +-
 .../MilkdropPreset/MotionVectors.cpp          | 10 ++-
 .../MilkdropPreset/MotionVectors.hpp          | 16 +++-
 .../MilkdropPreset/PerFrameContext.cpp        |  8 +-
 .../MilkdropPreset/PerFrameContext.hpp        |  6 ++
 .../MilkdropPreset/PerPixelContext.cpp        |  8 +-
 .../MilkdropPreset/PerPixelContext.hpp        |  6 ++
 .../MilkdropPreset/PerPixelMesh.cpp           | 14 +++-
 .../MilkdropPreset/PerPixelMesh.hpp           | 12 ++-
 .../MilkdropPreset/PresetFileParser.cpp       |  6 ++
 .../MilkdropPreset/PresetFileParser.hpp       |  6 ++
 .../MilkdropPreset/PresetState.cpp            |  6 ++
 .../MilkdropPreset/PresetState.hpp            | 38 ++++++----
 .../MilkdropPreset/ShapePerFrameContext.cpp   |  6 ++
 .../MilkdropPreset/ShapePerFrameContext.hpp   |  7 +-
 src/libprojectM/MilkdropPreset/VideoEcho.cpp  | 10 ++-
 src/libprojectM/MilkdropPreset/VideoEcho.hpp  | 10 ++-
 src/libprojectM/MilkdropPreset/Waveform.cpp   | 10 ++-
 src/libprojectM/MilkdropPreset/Waveform.hpp   |  9 ++-
 .../WaveformPerFrameContext.cpp               |  6 ++
 .../WaveformPerFrameContext.hpp               |  7 +-
 .../WaveformPerPointContext.cpp               |  8 +-
 .../WaveformPerPointContext.hpp               |  7 +-
 src/libprojectM/Preset.hpp                    | 13 ++--
 src/libprojectM/PresetFactory.cpp             |  4 +
 src/libprojectM/PresetFactory.hpp             |  4 +
 src/libprojectM/PresetFactoryManager.cpp      |  8 +-
 src/libprojectM/PresetFactoryManager.hpp      |  4 +
 src/libprojectM/ProjectM.cpp                  | 23 +++---
 src/libprojectM/ProjectM.hpp                  | 46 ++++++-----
 src/libprojectM/ProjectMCWrapper.cpp          | 10 ++-
 src/libprojectM/ProjectMCWrapper.hpp          |  4 +
 src/libprojectM/RandomNumberGenerators.hpp    |  9 ++-
 src/libprojectM/Renderer/CopyTexture.cpp      |  7 ++
 src/libprojectM/Renderer/CopyTexture.hpp      |  6 ++
 src/libprojectM/Renderer/FileScanner.cpp      | 38 ++++++----
 src/libprojectM/Renderer/FileScanner.hpp      | 20 ++---
 src/libprojectM/Renderer/Framebuffer.cpp      |  5 +-
 src/libprojectM/Renderer/Framebuffer.hpp      |  6 ++
 src/libprojectM/Renderer/IdleTextures.hpp     |  6 ++
 src/libprojectM/Renderer/MilkdropNoise.cpp    |  6 ++
 src/libprojectM/Renderer/MilkdropNoise.hpp    |  6 +-
 src/libprojectM/Renderer/PresetTransition.cpp |  6 ++
 src/libprojectM/Renderer/PresetTransition.hpp |  6 ++
 src/libprojectM/Renderer/RenderContext.hpp    |  6 ++
 src/libprojectM/Renderer/RenderItem.cpp       |  6 ++
 src/libprojectM/Renderer/RenderItem.hpp       |  6 ++
 src/libprojectM/Renderer/Sampler.cpp          |  6 ++
 src/libprojectM/Renderer/Sampler.hpp          |  8 +-
 src/libprojectM/Renderer/Shader.cpp           |  8 +-
 src/libprojectM/Renderer/Shader.hpp           |  6 ++
 src/libprojectM/Renderer/Texture.cpp          |  6 ++
 src/libprojectM/Renderer/Texture.hpp          |  6 ++
 .../Renderer/TextureAttachment.cpp            |  6 ++
 .../Renderer/TextureAttachment.hpp            |  6 ++
 src/libprojectM/Renderer/TextureManager.cpp   |  5 ++
 src/libprojectM/Renderer/TextureManager.hpp   |  5 ++
 .../Renderer/TextureSamplerDescriptor.cpp     |  8 +-
 .../Renderer/TextureSamplerDescriptor.hpp     |  6 ++
 .../Renderer/TransitionShaderManager.cpp      |  6 ++
 .../Renderer/TransitionShaderManager.hpp      |  6 ++
 src/libprojectM/StaticLibDummy.cpp            |  4 +
 src/libprojectM/TimeKeeper.cpp                |  4 +
 src/libprojectM/TimeKeeper.hpp                |  4 +
 src/playlist/Filter.cpp                       |  4 +-
 src/playlist/Filter.hpp                       |  4 +-
 src/playlist/Item.cpp                         |  4 +-
 src/playlist/Item.hpp                         |  4 +-
 src/playlist/Playlist.cpp                     |  4 +-
 src/playlist/Playlist.hpp                     |  4 +-
 src/playlist/PlaylistCWrapper.cpp             | 37 ++++-----
 src/playlist/PlaylistCWrapper.hpp             |  8 +-
 tests/libprojectM/PresetFileParserTest.cpp    |  2 +
 tests/playlist/APITest.cpp                    | 76 +++++++++----------
 tests/playlist/FilterTest.cpp                 | 24 +++---
 tests/playlist/ItemTest.cpp                   |  6 +-
 tests/playlist/PlaylistCWrapperMock.h         |  6 +-
 tests/playlist/PlaylistTest.cpp               | 23 +++---
 105 files changed, 798 insertions(+), 312 deletions(-)
 rename src/libprojectM/MilkdropPreset/{MilkdropPresetFactory.cpp => Factory.cpp} (72%)
 rename src/libprojectM/MilkdropPreset/{MilkdropPresetFactory.hpp => Factory.hpp} (78%)

diff --git a/src/libprojectM/BackgroundWorker.hpp b/src/libprojectM/BackgroundWorker.hpp
index 74d3e2c35..37ef8b5c8 100644
--- a/src/libprojectM/BackgroundWorker.hpp
+++ b/src/libprojectM/BackgroundWorker.hpp
@@ -3,6 +3,8 @@
 #include <condition_variable>
 #include <mutex>
 
+namespace libprojectM {
+
 /**
  * Small class to encapsulate synchronization of a simple background task runner
  */
@@ -70,3 +72,5 @@ private:
     volatile bool m_finished{ false };
 
 };
+
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/BlurTexture.cpp b/src/libprojectM/MilkdropPreset/BlurTexture.cpp
index 5f8bd2e51..637dc2bff 100644
--- a/src/libprojectM/MilkdropPreset/BlurTexture.cpp
+++ b/src/libprojectM/MilkdropPreset/BlurTexture.cpp
@@ -7,8 +7,11 @@
 
 #include <array>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 BlurTexture::BlurTexture()
-    : m_blurSampler(std::make_shared<Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR))
+    : m_blurSampler(std::make_shared<Renderer::Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR))
 {
     auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
 
@@ -38,7 +41,7 @@ BlurTexture::BlurTexture()
     glEnableVertexAttribArray(0);
     glEnableVertexAttribArray(1);
 
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, nullptr); // Position at index 0 and 1
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, nullptr);                                    // Position at index 0 and 1
     glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, reinterpret_cast<void*>(sizeof(float) * 2)); // Texture coord at index 2 and 3
 
     glBindVertexArray(0);
@@ -53,7 +56,7 @@ BlurTexture::BlurTexture()
             textureName = "blur" + std::to_string(i / 2 + 1);
         }
 
-        m_blurTextures[i] = std::make_shared<Texture>(textureName, 0, GL_TEXTURE_2D, 0, 0, false);
+        m_blurTextures[i] = std::make_shared<Renderer::Texture>(textureName, 0, GL_TEXTURE_2D, 0, 0, false);
     }
 }
 
@@ -68,9 +71,9 @@ void BlurTexture::SetRequiredBlurLevel(BlurTexture::BlurLevel level)
     m_blurLevel = std::max(level, m_blurLevel);
 }
 
-auto BlurTexture::GetDescriptorsForBlurLevel(BlurTexture::BlurLevel blurLevel) const -> std::vector<TextureSamplerDescriptor>
+auto BlurTexture::GetDescriptorsForBlurLevel(BlurTexture::BlurLevel blurLevel) const -> std::vector<Renderer::TextureSamplerDescriptor>
 {
-    std::vector<TextureSamplerDescriptor> descriptors;
+    std::vector<Renderer::TextureSamplerDescriptor> descriptors;
 
     if (blurLevel == BlurLevel::Blur3)
     {
@@ -91,7 +94,7 @@ auto BlurTexture::GetDescriptorsForBlurLevel(BlurTexture::BlurLevel blurLevel) c
     return descriptors;
 }
 
-void BlurTexture::Update(const Texture& sourceTexture, const PerFrameContext& perFrameContext)
+void BlurTexture::Update(const Renderer::Texture& sourceTexture, const PerFrameContext& perFrameContext)
 {
     if (m_blurLevel == BlurLevel::None)
     {
@@ -150,7 +153,7 @@ void BlurTexture::Update(const Texture& sourceTexture, const PerFrameContext& pe
         }
 
         // set pixel shader
-        Shader* blurShader;
+        Renderer::Shader* blurShader;
         if ((pass % 2) == 0)
         {
             blurShader = &m_blur1Shader;
@@ -255,10 +258,10 @@ void BlurTexture::Update(const Texture& sourceTexture, const PerFrameContext& pe
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, origDrawFramebuffer);
     glViewport(0, 0, sourceTexture.Width(), sourceTexture.Height());
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 }
 
-void BlurTexture::Bind(GLint& unit, Shader& shader) const
+void BlurTexture::Bind(GLint& unit, Renderer::Shader& shader) const
 {
     for (size_t i = 0; i < static_cast<size_t>(m_blurLevel) * 2; i++)
     {
@@ -309,7 +312,7 @@ void BlurTexture::GetSafeBlurMinMaxValues(const PerFrameContext& perFrameContext
     }
 }
 
-void BlurTexture::AllocateTextures(const Texture& sourceTexture)
+void BlurTexture::AllocateTextures(const Renderer::Texture& sourceTexture)
 {
     int width = sourceTexture.Width();
     int height = sourceTexture.Height();
@@ -354,9 +357,12 @@ void BlurTexture::AllocateTextures(const Texture& sourceTexture)
         }
 
         // This will automatically replace any old texture.
-        m_blurTextures[i] = std::make_shared<Texture>(textureName, width2, height2, false);
+        m_blurTextures[i] = std::make_shared<Renderer::Texture>(textureName, width2, height2, false);
     }
 
     m_sourceTextureWidth = sourceTexture.Width();
     m_sourceTextureHeight = sourceTexture.Height();
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/BlurTexture.hpp b/src/libprojectM/MilkdropPreset/BlurTexture.hpp
index 8ac566b7e..2f6a7998e 100644
--- a/src/libprojectM/MilkdropPreset/BlurTexture.hpp
+++ b/src/libprojectM/MilkdropPreset/BlurTexture.hpp
@@ -11,6 +11,9 @@
 #include <array>
 #include <memory>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PerFrameContext;
 class PresetState;
 
@@ -58,14 +61,14 @@ public:
      * The blur textures don't need to be present and can be empty placeholders.
      * @param blurLevel The blur level.
      */
-    auto GetDescriptorsForBlurLevel(BlurLevel blurLevel) const -> std::vector<TextureSamplerDescriptor>;
+    auto GetDescriptorsForBlurLevel(BlurLevel blurLevel) const -> std::vector<Renderer::TextureSamplerDescriptor>;
 
     /**
      * @brief Renders the required blur passes on the given texture.
      * @param sourceTexture The texture to create the blur levels from.
      * @param perFrameContext The per-frame variables.
      */
-    void Update(const Texture& sourceTexture, const PerFrameContext& perFrameContext);
+    void Update(const Renderer::Texture& sourceTexture, const PerFrameContext& perFrameContext);
 
     /**
      * @brief Binds the user-readable blur textures to the texture slots starting with the given index.
@@ -74,7 +77,7 @@ public:
      *                     free unit, which can be the same as the input slot if no blur textures
      *                     are used.
      */
-    void Bind(GLint& unit, Shader& shader) const;
+    void Bind(GLint& unit, Renderer::Shader& shader) const;
 
     /**
      * @brief Returns properly scaled and clamped vlur values from the given context.
@@ -93,19 +96,22 @@ private:
      * Allocates the blur textures.
      * @param sourceTexture The source texture.
      */
-    void AllocateTextures(const Texture& sourceTexture);
+    void AllocateTextures(const Renderer::Texture& sourceTexture);
 
     GLuint m_vboBlur; //!< Vertex buffer object for the fullscreen blur quad.
     GLuint m_vaoBlur; //!< Vertex array object for the fullscreen blur quad.
 
-    Shader m_blur1Shader; //!< The shader used on the first blur pass.
-    Shader m_blur2Shader; //!< The shader used for subsequent blur passes after the initial pass.
+    Renderer::Shader m_blur1Shader; //!< The shader used on the first blur pass.
+    Renderer::Shader m_blur2Shader; //!< The shader used for subsequent blur passes after the initial pass.
 
-    int m_sourceTextureWidth{}; //!< Width of the source texture used to create the blur textures.
+    int m_sourceTextureWidth{};  //!< Width of the source texture used to create the blur textures.
     int m_sourceTextureHeight{}; //!< Height of the source texture used to create the blur textures.
 
-    Framebuffer m_blurFramebuffer;                                        //!< The framebuffer used to draw the blur textures.
-    std::shared_ptr<Sampler> m_blurSampler;                               //!< The blur sampler.
-    std::array<std::shared_ptr<Texture>, NumBlurTextures> m_blurTextures; //!< The blur textures for each pass.
-    BlurLevel m_blurLevel{BlurLevel::None};                               //!< Current blur level.
+    Renderer::Framebuffer m_blurFramebuffer;                                        //!< The framebuffer used to draw the blur textures.
+    std::shared_ptr<Renderer::Sampler> m_blurSampler;                               //!< The blur sampler.
+    std::array<std::shared_ptr<Renderer::Texture>, NumBlurTextures> m_blurTextures; //!< The blur textures for each pass.
+    BlurLevel m_blurLevel{BlurLevel::None};                                         //!< Current blur level.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/Border.cpp b/src/libprojectM/MilkdropPreset/Border.cpp
index 0df79cec7..e20ff17ba 100644
--- a/src/libprojectM/MilkdropPreset/Border.cpp
+++ b/src/libprojectM/MilkdropPreset/Border.cpp
@@ -2,6 +2,9 @@
 
 #include <glm/gtc/type_ptr.hpp>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 Border::Border(PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
@@ -75,9 +78,12 @@ void Border::Draw(const PerFrameContext& presetPerFrameContext)
         }
     }
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 
     glDisable(GL_BLEND);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/Border.hpp b/src/libprojectM/MilkdropPreset/Border.hpp
index e71ab532f..8b258f6d0 100644
--- a/src/libprojectM/MilkdropPreset/Border.hpp
+++ b/src/libprojectM/MilkdropPreset/Border.hpp
@@ -5,10 +5,14 @@
 
 #include "Renderer/RenderItem.hpp"
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
+
 /**
  * @brief Renders a border around the screen.
  */
-class Border : public RenderItem
+class Border : public Renderer::RenderItem
 {
 public:
     Border() = delete;
@@ -26,3 +30,6 @@ public:
 private:
     PresetState& m_presetState; //!< The global preset state.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/CMakeLists.txt b/src/libprojectM/MilkdropPreset/CMakeLists.txt
index 5b95364d2..ba2e8bdb8 100644
--- a/src/libprojectM/MilkdropPreset/CMakeLists.txt
+++ b/src/libprojectM/MilkdropPreset/CMakeLists.txt
@@ -61,8 +61,8 @@ add_library(MilkdropPreset OBJECT
         MilkdropPreset.cpp
         MilkdropPreset.hpp
         MilkdropPresetExceptions.hpp
-        MilkdropPresetFactory.cpp
-        MilkdropPresetFactory.hpp
+        Factory.cpp
+        Factory.hpp
         MilkdropShader.cpp
         MilkdropShader.hpp
         MilkdropStaticShaders.cpp.in
diff --git a/src/libprojectM/MilkdropPreset/Constants.hpp b/src/libprojectM/MilkdropPreset/Constants.hpp
index 1d9d71cd9..407769678 100644
--- a/src/libprojectM/MilkdropPreset/Constants.hpp
+++ b/src/libprojectM/MilkdropPreset/Constants.hpp
@@ -6,6 +6,9 @@
 
 #include <Audio/AudioConstants.hpp>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 static constexpr int QVarCount = 32; //!< Number of Q variables available.
 static constexpr int TVarCount = 8; //!< Number of T variables available.
 
@@ -13,3 +16,6 @@ static constexpr int CustomWaveformCount = 4; //!< Number of custom waveforms (e
 static constexpr int CustomShapeCount = 4; //!< Number of custom shapes (expression-driven) which can be used in a preset.
 
 static constexpr int WaveformMaxPoints = 512; //!< Maximum number of waveform points.
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.cpp b/src/libprojectM/MilkdropPreset/CustomShape.cpp
index 7a3405f89..d424284f0 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.cpp
@@ -8,6 +8,9 @@
 
 #include <vector>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 CustomShape::CustomShape(PresetState& presetState)
     : m_presetState(presetState)
     , m_perFrameContext(presetState.globalMemory, &presetState.globalRegisters)
@@ -223,7 +226,7 @@ void CustomShape::Draw()
             glBindVertexArray(0);
 
             glBindTexture(GL_TEXTURE_2D, 0);
-            Sampler::Unbind(0);
+            Renderer::Sampler::Unbind(0);
         }
         else
         {
@@ -317,5 +320,8 @@ void CustomShape::Draw()
 #endif
     glDisable(GL_BLEND);
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.hpp b/src/libprojectM/MilkdropPreset/CustomShape.hpp
index 742d6d0aa..1d75eb77c 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.hpp
@@ -8,6 +8,9 @@
 
 #include <projectm-eval.h>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PresetFileParser;
 
 /**
@@ -16,7 +19,7 @@ class PresetFileParser;
  * The class creates two sets of VBO/VAO as it's only known later (in the Draw() call) whether the shape is textured
  * or not.
  */
-class CustomShape : public RenderItem
+class CustomShape : public Renderer::RenderItem
 {
 public:
     CustomShape(PresetState& presetState);
@@ -98,3 +101,6 @@ private:
 
     friend class ShapePerFrameContext;
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
index 2463bfddd..09516977d 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
@@ -12,6 +12,9 @@
 #include <algorithm>
 #include <cmath>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 static constexpr int CustomWaveformMaxSamples = std::max(libprojectM::Audio::WaveformSamples, libprojectM::Audio::SpectrumSamples);
 
 CustomWaveform::CustomWaveform(PresetState& presetState)
@@ -234,7 +237,7 @@ void CustomWaveform::Draw(const PerFrameContext& presetPerFrameContext)
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 
     glDisable(GL_BLEND);
 }
@@ -300,3 +303,6 @@ int CustomWaveform::SmoothWave(const CustomWaveform::ColoredPoint* inputVertices
 
     return outputIndex + 1;
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
index 8a52349cd..d83d53d24 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
@@ -7,9 +7,12 @@
 
 #include <vector>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PresetFileParser;
 
-class CustomWaveform : public RenderItem
+class CustomWaveform : public Renderer::RenderItem
 {
 public:
 
@@ -104,3 +107,6 @@ private:
     friend class WaveformPerFrameContext;
     friend class WaveformPerPointContext;
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
index 754885a6b..5e5efac74 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
@@ -1,5 +1,8 @@
 #include "DarkenCenter.hpp"
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 DarkenCenter::DarkenCenter(PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
@@ -48,5 +51,8 @@ void DarkenCenter::Draw()
 
     glDisable(GL_BLEND);
     glBindVertexArray(0);
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
index bb6ac22d8..dd3a4318f 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
@@ -4,10 +4,13 @@
 
 #include "Renderer/RenderItem.hpp"
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Darkens the screen center a bit on each frame.
  */
-class DarkenCenter : public RenderItem
+class DarkenCenter : public Renderer::RenderItem
 {
 public:
     DarkenCenter() = delete;
@@ -25,3 +28,6 @@ private:
     PresetState& m_presetState; //!< The global preset state.
     float m_aspectY{}; //!< Previous Y aspect ration.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPresetFactory.cpp b/src/libprojectM/MilkdropPreset/Factory.cpp
similarity index 72%
rename from src/libprojectM/MilkdropPreset/MilkdropPresetFactory.cpp
rename to src/libprojectM/MilkdropPreset/Factory.cpp
index 0377d0171..8179e3089 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPresetFactory.cpp
+++ b/src/libprojectM/MilkdropPreset/Factory.cpp
@@ -10,13 +10,15 @@
 //
 //
 //
-#include "MilkdropPresetFactory.hpp"
+#include "Factory.hpp"
 
-#include "MilkdropPreset.hpp"
 #include "IdlePreset.hpp"
+#include "MilkdropPreset.hpp"
 
-std::unique_ptr<Preset>
-MilkdropPresetFactory::LoadPresetFromFile(const std::string& filename)
+namespace libprojectM {
+namespace MilkdropPreset {
+
+std::unique_ptr<::libprojectM::Preset> Factory::LoadPresetFromFile(const std::string& filename)
 {
     std::string path;
     auto protocol = PresetFactory::Protocol(filename, path);
@@ -35,7 +37,10 @@ MilkdropPresetFactory::LoadPresetFromFile(const std::string& filename)
     }
 }
 
-std::unique_ptr<Preset> MilkdropPresetFactory::LoadPresetFromStream(std::istream& data)
+std::unique_ptr<Preset> Factory::LoadPresetFromStream(std::istream& data)
 {
     return std::make_unique<MilkdropPreset>(data);
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPresetFactory.hpp b/src/libprojectM/MilkdropPreset/Factory.hpp
similarity index 78%
rename from src/libprojectM/MilkdropPreset/MilkdropPresetFactory.hpp
rename to src/libprojectM/MilkdropPreset/Factory.hpp
index 7ea6ca7a2..6e1058920 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPresetFactory.hpp
+++ b/src/libprojectM/MilkdropPreset/Factory.hpp
@@ -16,7 +16,10 @@
 
 #include <memory>
 
-class MilkdropPresetFactory : public PresetFactory
+namespace libprojectM {
+namespace MilkdropPreset {
+
+class Factory : public PresetFactory
 {
 
 public:
@@ -30,3 +33,6 @@ public:
     }
 
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/Filters.cpp b/src/libprojectM/MilkdropPreset/Filters.cpp
index 875e07120..9a82d63c7 100644
--- a/src/libprojectM/MilkdropPreset/Filters.cpp
+++ b/src/libprojectM/MilkdropPreset/Filters.cpp
@@ -2,6 +2,9 @@
 
 #include "projectM-opengl.h"
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 Filters::Filters(const PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
@@ -53,7 +56,7 @@ void Filters::Draw()
 
     glBindVertexArray(0);
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 
     glDisable(GL_BLEND);
 }
@@ -119,3 +122,6 @@ void Filters::UpdateMesh()
     glBindVertexArray(0);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/Filters.hpp b/src/libprojectM/MilkdropPreset/Filters.hpp
index 017c6fa85..c00084654 100644
--- a/src/libprojectM/MilkdropPreset/Filters.hpp
+++ b/src/libprojectM/MilkdropPreset/Filters.hpp
@@ -4,10 +4,13 @@
 
 #include <Renderer/RenderItem.hpp>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Classic Milkdrop 1 postprocessing effects.
  */
-class Filters : public RenderItem
+class Filters : public Renderer::RenderItem
 {
 public:
     Filters() = delete;
@@ -48,3 +51,6 @@ private:
     int m_viewportWidth{}; //!< Last known viewport width
     int m_viewportHeight{}; //!< Last known viewport height
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/FinalComposite.cpp b/src/libprojectM/MilkdropPreset/FinalComposite.cpp
index d2dc1c460..cc87300c4 100644
--- a/src/libprojectM/MilkdropPreset/FinalComposite.cpp
+++ b/src/libprojectM/MilkdropPreset/FinalComposite.cpp
@@ -4,6 +4,9 @@
 
 #include <cstddef>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 static std::string const defaultCompositeShader = "shader_body\n{\nret = tex2D(sampler_main, uv).xyz;\n}";
 
 FinalComposite::FinalComposite()
@@ -41,7 +44,7 @@ void FinalComposite::LoadCompositeShader(const PresetState& presetState)
                 std::cerr << "[Composite Shader] Loaded composite shader code." << std::endl;
 #endif
             }
-            catch (ShaderException& ex)
+            catch (Renderer::ShaderException& ex)
             {
 #ifdef MILKDROP_PRESET_DEBUG
                 std::cerr << "[Composite Shader] Error loading composite warp shader code:" << ex.message() << std::endl;
@@ -85,7 +88,7 @@ void FinalComposite::CompileCompositeShader(PresetState& presetState)
             std::cerr << "[Composite Shader] Successfully compiled composite shader code." << std::endl;
 #endif
         }
-        catch (ShaderException& ex)
+        catch (Renderer::ShaderException& ex)
         {
 #ifdef MILKDROP_PRESET_DEBUG
             std::cerr << "[Composite Shader] Error compiling composite warp shader code:" << ex.message() << std::endl;
@@ -128,7 +131,7 @@ void FinalComposite::Draw(const PresetState& presetState, const PerFrameContext&
     }
 
     glBindVertexArray(0);
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 }
 
 auto FinalComposite::HasCompositeShader() const -> bool
@@ -375,3 +378,6 @@ void FinalComposite::ApplyHueShaderColors(const PresetState& presetState)
         }
     }
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/FinalComposite.hpp b/src/libprojectM/MilkdropPreset/FinalComposite.hpp
index a5dba3b84..b9cf50b40 100644
--- a/src/libprojectM/MilkdropPreset/FinalComposite.hpp
+++ b/src/libprojectM/MilkdropPreset/FinalComposite.hpp
@@ -9,10 +9,13 @@
 #include <array>
 #include <memory>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Draws the final composite effect, either a shader or Milkdrop 1 effects.
  */
-class FinalComposite : public RenderItem
+class FinalComposite : public Renderer::RenderItem
 {
 public:
     FinalComposite();
@@ -98,3 +101,6 @@ private:
     std::unique_ptr<VideoEcho> m_videoEcho; //!< Video echo effect. Used if no composite shader is loaded and video echo is enabled.
     std::unique_ptr<Filters> m_filters; //!< Color post-processing filters. Used if no composite shader is loaded.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/IdlePreset.cpp b/src/libprojectM/MilkdropPreset/IdlePreset.cpp
index 831617723..bada4f924 100644
--- a/src/libprojectM/MilkdropPreset/IdlePreset.cpp
+++ b/src/libprojectM/MilkdropPreset/IdlePreset.cpp
@@ -3,8 +3,10 @@
 #include <sstream>
 #include <string>
 
-// Original preset name: "Geiss & Sperl - Feedback (projectM idle HDR mix).milk"
+namespace libprojectM {
+namespace MilkdropPreset {
 
+// Original preset name: "Geiss & Sperl - Feedback (projectM idle HDR mix).milk"
 std::string IdlePresets::presetText()
 {    return R"([preset00]
 fRating=2.000000
@@ -194,3 +196,6 @@ IdlePresets::allocate()
     std::istringstream in(presetText());
     return std::unique_ptr<Preset>(new MilkdropPreset(in));
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/IdlePreset.hpp b/src/libprojectM/MilkdropPreset/IdlePreset.hpp
index 923d28553..c3e08cdde 100644
--- a/src/libprojectM/MilkdropPreset/IdlePreset.hpp
+++ b/src/libprojectM/MilkdropPreset/IdlePreset.hpp
@@ -3,12 +3,12 @@
 #include <memory>
 #include <string>
 
-class MilkdropPresetFactory;
-
-class PresetOutputs;
+namespace libprojectM {
 
 class Preset;
 
+namespace MilkdropPreset {
+
 /**
  * A preset that does not depend on the file system to be loaded. This allows projectM to render
  * something (ie. self indulgent project advertising) even when no valid preset directory is found.
@@ -24,8 +24,11 @@ public:
      * @brief Allocate a new idle preset instance.
      * @return A newly allocated auto pointer of an idle preset instance
      */
-    static std::unique_ptr<Preset> allocate();
+    static std::unique_ptr<::libprojectM::Preset> allocate();
 
 private:
     static std::string presetText();
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
index 6c730271b..d2c3e5473 100755
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
@@ -21,14 +21,17 @@
 
 #include "MilkdropPreset.hpp"
 
+#include "Factory.hpp"
 #include "MilkdropPresetExceptions.hpp"
-#include "MilkdropPresetFactory.hpp"
 #include "PresetFileParser.hpp"
 
 #ifdef MILKDROP_PRESET_DEBUG
 #include <iostream>
 #endif
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 MilkdropPreset::MilkdropPreset(const std::string& absoluteFilePath)
     : m_absoluteFilePath(absoluteFilePath)
     , m_perFrameContext(m_state.globalMemory, &m_state.globalRegisters)
@@ -52,7 +55,7 @@ MilkdropPreset::MilkdropPreset(std::istream& presetData)
     Load(presetData);
 }
 
-void MilkdropPreset::Initialize(const RenderContext& renderContext)
+void MilkdropPreset::Initialize(const Renderer::RenderContext& renderContext)
 {
     assert(renderContext.textureManager);
     m_state.renderContext = renderContext;
@@ -72,7 +75,7 @@ void MilkdropPreset::Initialize(const RenderContext& renderContext)
     m_finalComposite.CompileCompositeShader(m_state);
 }
 
-void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audioData, const RenderContext& renderContext)
+void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audioData, const Renderer::RenderContext& renderContext)
 {
     m_state.audioData = audioData;
     m_state.renderContext = renderContext;
@@ -166,13 +169,13 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     m_isFirstFrame = false;
 }
 
-auto MilkdropPreset::OutputTexture() const -> std::shared_ptr<Texture>
+auto MilkdropPreset::OutputTexture() const -> std::shared_ptr<Renderer::Texture>
 {
     // the composited image is always stored in the "current" framebuffer after a frame is rendered.
     return m_framebuffer.GetColorAttachmentTexture(m_currentFrameBuffer, 0);
 }
 
-void MilkdropPreset::DrawInitialImage(const std::shared_ptr<Texture>& image, const RenderContext& renderContext)
+void MilkdropPreset::DrawInitialImage(const std::shared_ptr<Renderer::Texture>& image, const Renderer::RenderContext& renderContext)
 {
     m_framebuffer.SetSize(renderContext.viewportSizeX, renderContext.viewportSizeY);
 
@@ -237,11 +240,11 @@ void MilkdropPreset::Load(std::istream& stream)
 void MilkdropPreset::InitializePreset(PresetFileParser& parsedFile)
 {
     // Create the offscreen rendering surfaces.
-    m_motionVectorUVMap = std::make_shared<TextureAttachment>(GL_RG16F, GL_RG, GL_FLOAT, 0, 0);
+    m_motionVectorUVMap = std::make_shared<Renderer::TextureAttachment>(GL_RG16F, GL_RG, GL_FLOAT, 0, 0);
     m_framebuffer.CreateColorAttachment(0, 0); // Main image 1
     m_framebuffer.CreateColorAttachment(1, 0); // Main image 2
 
-    Framebuffer::Unbind();
+    Renderer::Framebuffer::Unbind();
 
     // Load global init variables into the state
     m_state.Initialize(parsedFile);
@@ -309,4 +312,7 @@ auto MilkdropPreset::ParseFilename(const std::string& filename) -> std::string
     }
 
     return filename.substr(start + 1, filename.length());
-}
\ No newline at end of file
+}
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
index 963ad9aa5..cd55339a9 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
@@ -44,10 +44,13 @@
 #include <memory>
 #include <string>
 
-class MilkdropPresetFactory;
+namespace libprojectM {
+namespace MilkdropPreset {
+
+class Factory;
 class PresetFileParser;
 
-class MilkdropPreset : public Preset
+class MilkdropPreset : public ::libprojectM::Preset
 {
 
 public:
@@ -69,7 +72,7 @@ public:
      * @brief Initializes the preset with rendering-related data.
      * @param renderContext The initial render context.
      */
-    void Initialize(const RenderContext& renderContext) override;
+    void Initialize(const Renderer::RenderContext& renderContext) override;
 
     /**
      * @brief Renders the preset.
@@ -77,11 +80,11 @@ public:
      * @param renderContext The current rendering context/information.
      */
     void RenderFrame(const libprojectM::Audio::FrameAudioData& audioData,
-                     const RenderContext& renderContext) override;
+                     const Renderer::RenderContext& renderContext) override;
 
-    auto OutputTexture() const -> std::shared_ptr<Texture> override;
+    auto OutputTexture() const -> std::shared_ptr<Renderer::Texture> override;
 
-    void DrawInitialImage(const std::shared_ptr<Texture>& image, const RenderContext& renderContext) override;
+    void DrawInitialImage(const std::shared_ptr<Renderer::Texture>& image, const Renderer::RenderContext& renderContext) override;
 
 private:
     void PerFrameUpdate();
@@ -104,10 +107,10 @@ private:
     std::string m_absoluteFilePath; //!< The absolute file path of the MilkdropPreset
     std::string m_absolutePath;     //!< The absolute path of the MilkdropPreset
 
-    Framebuffer m_framebuffer{2};                           //!< Preset rendering framebuffer with two surfaces (last frame and current frame).
-    int m_currentFrameBuffer{0};                            //!< Framebuffer ID of the current frame.
-    int m_previousFrameBuffer{1};                           //!< Framebuffer ID of the previous frame.
-    std::shared_ptr<TextureAttachment> m_motionVectorUVMap; //!< The UV map of the previous frame's warp mesh, used for motion vector reverse propagation.
+    Renderer::Framebuffer m_framebuffer{2};                           //!< Preset rendering framebuffer with two surfaces (last frame and current frame).
+    int m_currentFrameBuffer{0};                                      //!< Framebuffer ID of the current frame.
+    int m_previousFrameBuffer{1};                                     //!< Framebuffer ID of the previous frame.
+    std::shared_ptr<Renderer::TextureAttachment> m_motionVectorUVMap; //!< The UV map of the previous frame's warp mesh, used for motion vector reverse propagation.
 
     PresetState m_state;               //!< Preset state container.
     PerFrameContext m_perFrameContext; //!< Preset per-frame evaluation code context.
@@ -121,9 +124,12 @@ private:
     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.
-    CopyTexture m_flipTexture;                                                          //!< Texture flip filter
+    Renderer::CopyTexture m_flipTexture;                                                //!< Texture flip filter
 
     FinalComposite m_finalComposite; //!< Final composite shader or filters.
 
     bool m_isFirstFrame{true}; //!< Controls drawing the motion vectors starting with the second frame.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPresetExceptions.hpp b/src/libprojectM/MilkdropPreset/MilkdropPresetExceptions.hpp
index 10eaec01c..37ec50ab7 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPresetExceptions.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPresetExceptions.hpp
@@ -3,6 +3,9 @@
 #include <string>
 #include <exception>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Exception for preset loading errors.
  */
@@ -47,3 +50,6 @@ public:
 private:
     std::string m_message;
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropShader.cpp b/src/libprojectM/MilkdropPreset/MilkdropShader.cpp
index a0df8d2a5..b1ffcf986 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropShader.cpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropShader.cpp
@@ -15,6 +15,9 @@
 #include <regex>
 #include <set>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 using libprojectM::MilkdropPreset::MilkdropStaticShaders;
 
 static auto floatRand = []() { return static_cast<float>(rand() % 7381) / 7380.0f; };
@@ -72,10 +75,10 @@ void MilkdropShader::LoadTexturesAndCompile(PresetState& presetState)
         // The "main" and "blurX" textures are preset-specific and are not managed by TextureManager.
         if (lowerCaseName == "main")
         {
-            TextureSamplerDescriptor desc(presetState.mainTexture.lock(),
-                                          presetState.renderContext.textureManager->GetSampler(name),
-                                          name,
-                                          "main");
+            Renderer::TextureSamplerDescriptor desc(presetState.mainTexture.lock(),
+                                                    presetState.renderContext.textureManager->GetSampler(name),
+                                                    name,
+                                                    "main");
             m_mainTextureDescriptors.push_back(std::move(desc));
             continue;
         }
@@ -99,18 +102,17 @@ void MilkdropShader::LoadTexturesAndCompile(PresetState& presetState)
 
         // Random textures need special treatment.
         if (lowerCaseName.length() >= 6 &&
-            lowerCaseName.substr(0, 4) == "rand"
-            && std::isdigit(lowerCaseName.at(4), loc)
-            && std::isdigit(lowerCaseName.at(5), loc)
-            )
+            lowerCaseName.substr(0, 4) == "rand" && std::isdigit(lowerCaseName.at(4), loc) && std::isdigit(lowerCaseName.at(5), loc))
         {
             // First look up the random texture index in the preset state so the texture matches between warp and composite shaders
             int randomSlot = -1;
-            try {
+            try
+            {
                 randomSlot = std::stoi(lowerCaseName.substr(4, 2));
             }
             catch (...) // Ignore any conversion errors.
-            {}
+            {
+            }
 
             if (randomSlot >= 0 && randomSlot <= 15)
             {
@@ -322,7 +324,7 @@ void MilkdropShader::LoadVariables(const PresetState& presetState, const PerFram
     }
 }
 
-auto MilkdropShader::Shader() -> class Shader&
+auto MilkdropShader::Shader() -> Renderer::Shader&
 {
     return m_shader;
 }
@@ -332,7 +334,7 @@ void MilkdropShader::PreprocessPresetShader(std::string& program)
 
     if (program.length() <= 0)
     {
-        throw ShaderException("Preset shader is declared, but empty.");
+        throw Renderer::ShaderException("Preset shader is declared, but empty.");
     }
 
     size_t found;
@@ -378,7 +380,7 @@ void MilkdropShader::PreprocessPresetShader(std::string& program)
     }
     else
     {
-        throw ShaderException("Preset shader is missing \"shader_body\" entry point.");
+        throw Renderer::ShaderException("Preset shader is missing \"shader_body\" entry point.");
     }
 
     // replace the "{" immediately following shader_body with some variable declarations
@@ -394,7 +396,7 @@ void MilkdropShader::PreprocessPresetShader(std::string& program)
     }
     else
     {
-        throw ShaderException("Preset shader has no opening braces.");
+        throw Renderer::ShaderException("Preset shader has no opening braces.");
     }
 
     // replace "}" with return statement (this can probably be optimized for the GLSL conversion...)
@@ -406,7 +408,7 @@ void MilkdropShader::PreprocessPresetShader(std::string& program)
     }
     else
     {
-        throw ShaderException("Preset shader has no closing brace.");
+        throw Renderer::ShaderException("Preset shader has no closing brace.");
     }
 
     // Find matching closing brace and cut off excess text after shader's main function
@@ -551,7 +553,7 @@ void MilkdropShader::TranspileHLSLShader(const PresetState& presetState, std::st
     std::string sourcePreprocessed;
     if (!parser.ApplyPreprocessor("", program.c_str(), program.size(), sourcePreprocessed))
     {
-        throw ShaderException("Error translating HLSL " + shaderTypeString + " shader: Preprocessing failed.\nSource:\n" + program);
+        throw Renderer::ShaderException("Error translating HLSL " + shaderTypeString + " shader: Preprocessing failed.\nSource:\n" + program);
     }
 
     // Remove previous shader declarations
@@ -604,7 +606,7 @@ void MilkdropShader::TranspileHLSLShader(const PresetState& presetState, std::st
     // First, parse HLSL into a tree
     if (!parser.Parse("", sourcePreprocessed.c_str(), sourcePreprocessed.size()))
     {
-        throw ShaderException("Error translating HLSL " + shaderTypeString + " shader: HLSL parsing failed.\nSource:\n" + sourcePreprocessed);
+        throw Renderer::ShaderException("Error translating HLSL " + shaderTypeString + " shader: HLSL parsing failed.\nSource:\n" + sourcePreprocessed);
     }
 
     // Then generate GLSL from the resulting parser tree
@@ -612,7 +614,7 @@ void MilkdropShader::TranspileHLSLShader(const PresetState& presetState, std::st
                             MilkdropStaticShaders::Get()->GetGlslGeneratorVersion(),
                             "PS"))
     {
-        throw ShaderException("Error translating HLSL " + shaderTypeString + " shader: GLSL generating failes.\nSource:\n" + sourcePreprocessed);
+        throw Renderer::ShaderException("Error translating HLSL " + shaderTypeString + " shader: GLSL generating failes.\nSource:\n" + sourcePreprocessed);
     }
 
     // Now we have GLSL source for the preset shader program (hopefully it's valid!)
@@ -652,3 +654,6 @@ void MilkdropShader::UpdateMaxBlurLevel(BlurTexture::BlurLevel requestedLevel)
         m_samplerNames.insert("blur1");
     }
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropShader.hpp b/src/libprojectM/MilkdropPreset/MilkdropShader.hpp
index 2abdb7081..5c7bec8ff 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropShader.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropShader.hpp
@@ -14,6 +14,9 @@
 #include <array>
 #include <set>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PerFrameContext;
 class PresetState;
 
@@ -61,7 +64,7 @@ public:
      * @brief Returns the contained shader.
      * @return The shader program wrapper.
      */
-    auto Shader() -> class Shader&;
+    auto Shader() -> Renderer::Shader&;
 
 private:
     /**
@@ -95,8 +98,8 @@ private:
     std::string m_preprocessedCode;            //!< The preprocessed preset shader code.
 
     std::set<std::string> m_samplerNames;                                        //!< All sampler names referenced in the shader code.
-    std::vector<TextureSamplerDescriptor> m_mainTextureDescriptors;              //!< Descriptors for all main texture references.
-    std::vector<TextureSamplerDescriptor> m_textureSamplerDescriptors;           //!< Descriptors of all referenced samplers in the shader code.
+    std::vector<Renderer::TextureSamplerDescriptor> m_mainTextureDescriptors;              //!< Descriptors for all main texture references.
+    std::vector<Renderer::TextureSamplerDescriptor> m_textureSamplerDescriptors;           //!< Descriptors of all referenced samplers in the shader code.
     BlurTexture::BlurLevel m_maxBlurLevelRequired{BlurTexture::BlurLevel::None}; //!< Max blur level of main texture required by this shader.
 
     std::array<float, 4> m_randValues{};               //!< Random values which don't change every frame.
@@ -104,5 +107,8 @@ private:
     std::array<glm::vec3, 20> m_randRotationCenters{}; //!< Random rotation center vectors which don't change every frame.
     std::array<glm::vec3, 20> m_randRotationSpeeds{};  //!< Random rotation speeds which don't change every frame.
 
-    class Shader m_shader;
+    Renderer::Shader m_shader;
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.cpp.in b/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.cpp.in
index 496fcfcef..8b1239fc1 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.cpp.in
+++ b/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.cpp.in
@@ -13,7 +13,7 @@ namespace MilkdropPreset {
 MilkdropStaticShaders::MilkdropStaticShaders(bool useGLES)
     : m_useGLES(useGLES)
 {
-    m_GLSLVersion = Shader::GetShaderLanguageVersion();
+    m_GLSLVersion = Renderer::Shader::GetShaderLanguageVersion();
 
     if (m_GLSLVersion.major == 0)
     {
diff --git a/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.hpp.in b/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.hpp.in
index ab602b65a..dc110f777 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.hpp.in
+++ b/src/libprojectM/MilkdropPreset/MilkdropStaticShaders.hpp.in
@@ -63,9 +63,9 @@ private:
      */
     std::string AddVersionHeader(std::string shader_text);
 
-    bool m_useGLES{false}; //!< Whether or not to use GLES shaders.
-    Shader::GlslVersion m_GLSLVersion{}; //!< The queried GLSL version.
-    std::string m_versionHeader; //!< The version header to prepended by AddVersionHeader.
+    bool m_useGLES{false};                             //!< Whether or not to use GLES shaders.
+    Renderer::Shader::GlslVersion m_GLSLVersion{};     //!< The queried GLSL version.
+    std::string m_versionHeader;                       //!< The version header to prepended by AddVersionHeader.
     M4::GLSLGenerator::Version m_GLSLGeneratorVersion; //!< The GLSL generator version to pass to the hlslparser generator.
 };
 
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.cpp b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
index 36fcd4554..02f3825e2 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.cpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
@@ -4,6 +4,9 @@
 
 #include <Renderer/TextureManager.hpp>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 MotionVectors::MotionVectors(PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
@@ -24,7 +27,7 @@ void MotionVectors::InitVertexAttrib()
     glVertexAttribIPointer(2, 1, GL_INT, sizeof(MotionVectorVertex), reinterpret_cast<void*>(offsetof(MotionVectorVertex, index)));
 }
 
-void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<class Texture> motionTexture)
+void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture)
 {
     // Don't draw if invisible.
     if (*presetPerFrameContext.mv_a < 0.0001f)
@@ -146,7 +149,10 @@ void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shar
     glDisable(GL_LINE_SMOOTH);
 #endif
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 
     glDisable(GL_BLEND);
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.hpp b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
index 5720d3add..46bf615cf 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.hpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
@@ -5,6 +5,11 @@
 
 #include "Renderer/RenderItem.hpp"
 
+#include <memory>
+
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Draws a flexible motion vector field.
  *
@@ -14,7 +19,7 @@
  * @todo Reverse-engineer the original Milkdrop code and reimplement it properly.
  *       https://github.com/projectM-visualizer/milkdrop2/blob/f05b0d811a87a17c4624170c26c93bac39b05bde/src/vis_milk2/milkdropfs.cpp#L1239
  */
-class MotionVectors : public RenderItem
+class MotionVectors : public Renderer::RenderItem
 {
 public:
     MotionVectors() = delete;
@@ -28,7 +33,7 @@ public:
      * @param presetPerFrameContext The per-frame context variables.
      * @param motionTexture The u/v "motion" texture written by the warp shader.
      */
-    void Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<class Texture> motionTexture);
+    void Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture);
 
 private:
     struct MotionVectorVertex
@@ -40,6 +45,9 @@ private:
 
     PresetState& m_presetState; //!< The global preset state.
 
-    Shader m_motionVectorShader; //!< The motion vector shader, calculates the trace positions in the GPU.
-    std::shared_ptr<Sampler> m_sampler{std::make_shared<Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR)}; //!< The texture sampler.
+    Renderer::Shader m_motionVectorShader; //!< The motion vector shader, calculates the trace positions in the GPU.
+    std::shared_ptr<Renderer::Sampler> m_sampler{std::make_shared<Renderer::Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR)}; //!< The texture sampler.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerFrameContext.cpp b/src/libprojectM/MilkdropPreset/PerFrameContext.cpp
index 6634cd4d4..5def51af5 100644
--- a/src/libprojectM/MilkdropPreset/PerFrameContext.cpp
+++ b/src/libprojectM/MilkdropPreset/PerFrameContext.cpp
@@ -9,6 +9,9 @@
 #define REG_VAR(var) \
     var = projectm_eval_context_register_variable(perFrameCodeContext, #var);
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 PerFrameContext::PerFrameContext(projectm_eval_mem_buffer gmegabuf, PRJM_EVAL_F (*globalRegisters)[100])
     : perFrameCodeContext(projectm_eval_context_create(gmegabuf, globalRegisters))
 {
@@ -257,4 +260,7 @@ void PerFrameContext::ExecutePerFrameCode()
     {
         projectm_eval_code_execute(perFrameCodeHandle);
     }
-}
\ No newline at end of file
+}
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerFrameContext.hpp b/src/libprojectM/MilkdropPreset/PerFrameContext.hpp
index 838eb7863..aca786ba8 100644
--- a/src/libprojectM/MilkdropPreset/PerFrameContext.hpp
+++ b/src/libprojectM/MilkdropPreset/PerFrameContext.hpp
@@ -4,6 +4,9 @@
 
 #include <projectm-eval.h>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Hold the per-frame state variables and code execution context.
  *
@@ -142,3 +145,6 @@ public:
 
     PRJM_EVAL_F q_values_after_init_code[QVarCount]{};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerPixelContext.cpp b/src/libprojectM/MilkdropPreset/PerPixelContext.cpp
index e6f7b43ab..378258dc0 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelContext.cpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelContext.cpp
@@ -9,6 +9,9 @@
 #define REG_VAR(var) \
     var = projectm_eval_context_register_variable(perPixelCodeContext, #var);
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 PerPixelContext::PerPixelContext(projectm_eval_mem_buffer gmegabuf, PRJM_EVAL_F (*globalRegisters)[100])
     : perPixelCodeContext(projectm_eval_context_create(gmegabuf, globalRegisters))
 {
@@ -123,4 +126,7 @@ void PerPixelContext::ExecutePerPixelCode()
     {
         projectm_eval_code_execute(perPixelCodeHandle);
     }
-}
\ No newline at end of file
+}
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerPixelContext.hpp b/src/libprojectM/MilkdropPreset/PerPixelContext.hpp
index 7e3cc0bb2..9bd25ba1b 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelContext.hpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelContext.hpp
@@ -5,6 +5,9 @@
 
 #include <projectm-eval.h>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PerPixelContext
 {
 public:
@@ -90,3 +93,6 @@ public:
     PRJM_EVAL_F* aspectx{};
     PRJM_EVAL_F* aspecty{};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
index 3aef86856..3be8970f7 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
@@ -10,6 +10,9 @@
 #include <algorithm>
 #include <cmath>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 PerPixelMesh::PerPixelMesh()
     : RenderItem()
 {
@@ -62,7 +65,7 @@ void PerPixelMesh::LoadWarpShader(const PresetState& presetState)
                 std::cerr << "[Warp Shader] Loaded preset warp shader code." << std::endl;
 #endif
             }
-            catch (ShaderException& ex)
+            catch (Renderer::ShaderException& ex)
             {
 #ifdef MILKDROP_PRESET_DEBUG
                 std::cerr << "[Warp Shader] Error loading warp shader code:" << ex.message() << std::endl;
@@ -84,7 +87,7 @@ void PerPixelMesh::CompileWarpShader(PresetState& presetState)
             std::cerr << "[Warp Shader] Successfully compiled warp shader code." << std::endl;
 #endif
         }
-        catch (ShaderException& ex)
+        catch (Renderer::ShaderException& ex)
         {
 #ifdef MILKDROP_PRESET_DEBUG
             std::cerr << "[Warp Shader] Error compiling warp shader code:" << ex.message() << std::endl;
@@ -379,6 +382,9 @@ void PerPixelMesh::WarpedBlit(const PresetState& presetState,
     glBindVertexArray(0);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 
-    Sampler::Unbind(0);
-    Shader::Unbind();
+    Renderer::Sampler::Unbind(0);
+    Renderer::Shader::Unbind();
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
index 9f3b7638f..6dcef4299 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
@@ -6,6 +6,9 @@
 #include <cstdint>
 #include <vector>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PresetState;
 class PerFrameContext;
 class PerPixelContext;
@@ -24,7 +27,7 @@ class MilkdropShader;
  *
  * The mesh size can be changed between frames, the class will reallocate the buffers if needed.
  */
-class PerPixelMesh : public RenderItem
+class PerPixelMesh : public Renderer::RenderItem
 {
 public:
     PerPixelMesh();
@@ -119,7 +122,10 @@ private:
     std::vector<int> m_listIndices; //!< List of vertex indices to render.
     VertexList m_drawVertices;      //!< Temp data buffer for the vertices to be drawn.
 
-    Shader m_perPixelMeshShader;                            //!< Special shader which calculates the per-pixel UV coordinates.
+    Renderer::Shader m_perPixelMeshShader;                            //!< Special shader which calculates the per-pixel UV coordinates.
     std::unique_ptr<MilkdropShader> m_warpShader;           //!< The warp shader. Either preset-defined or a default shader.
-    Sampler m_perPixelSampler{GL_CLAMP_TO_EDGE, GL_LINEAR}; //!< The main texture sampler.
+    Renderer::Sampler m_perPixelSampler{GL_CLAMP_TO_EDGE, GL_LINEAR}; //!< The main texture sampler.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PresetFileParser.cpp b/src/libprojectM/MilkdropPreset/PresetFileParser.cpp
index 8b30a2613..5a88d9915 100644
--- a/src/libprojectM/MilkdropPreset/PresetFileParser.cpp
+++ b/src/libprojectM/MilkdropPreset/PresetFileParser.cpp
@@ -6,6 +6,9 @@
 #include <sstream>
 #include <vector>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 auto PresetFileParser::Read(const std::string& presetFile) -> bool
 {
     std::ifstream presetStream(presetFile.c_str(), std::ios_base::in | std::ios_base::binary);
@@ -174,3 +177,6 @@ void PresetFileParser::ParseLine(const std::string& line)
         m_presetValues.emplace(std::move(varName), std::move(value));
     }
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PresetFileParser.hpp b/src/libprojectM/MilkdropPreset/PresetFileParser.hpp
index dd1ecb8b7..cd2e00659 100644
--- a/src/libprojectM/MilkdropPreset/PresetFileParser.hpp
+++ b/src/libprojectM/MilkdropPreset/PresetFileParser.hpp
@@ -3,6 +3,9 @@
 #include <map>
 #include <string>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Milkdrop preset file parser
  *
@@ -117,3 +120,6 @@ protected:
 private:
     ValueMap m_presetValues; //!< Map with preset keys and their value.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PresetState.cpp b/src/libprojectM/MilkdropPreset/PresetState.cpp
index d21148fc9..5f20bae1d 100644
--- a/src/libprojectM/MilkdropPreset/PresetState.cpp
+++ b/src/libprojectM/MilkdropPreset/PresetState.cpp
@@ -6,6 +6,9 @@
 
 #include <random>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 const glm::mat4 PresetState::orthogonalProjection = glm::ortho(-1.0f, 1.0f, 1.0f, -1.0f, -40.0f, 40.0f);
 const glm::mat4 PresetState::orthogonalProjectionFlipped = glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, -40.0f, 40.0f);
 
@@ -159,3 +162,6 @@ void PresetState::Initialize(PresetFileParser& parsedFile)
     warpShader = parsedFile.GetCode("warp_");
     compositeShader = parsedFile.GetCode("comp_");
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PresetState.hpp b/src/libprojectM/MilkdropPreset/PresetState.hpp
index 60c17f96f..dd767527a 100644
--- a/src/libprojectM/MilkdropPreset/PresetState.hpp
+++ b/src/libprojectM/MilkdropPreset/PresetState.hpp
@@ -21,6 +21,9 @@
 
 #include <string>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 class PresetFileParser;
 
 using BlendableFloat = float; //!< Currently a placeholder to mark blendable values.
@@ -124,41 +127,44 @@ public:
     int frame{0};
     double progress{0.0};
 
-    int presetVersion{100}; //!< Value of MILKDROP_PRESET_VERSION in preset files.
-    int warpShaderVersion{2}; //!< PSVERSION or PSVERSION_WARP.
+    int presetVersion{100};        //!< Value of MILKDROP_PRESET_VERSION in preset files.
+    int warpShaderVersion{2};      //!< PSVERSION or PSVERSION_WARP.
     int compositeShaderVersion{2}; //!< PSVERSION or PSVERSION_COMP.
 
     std::array<float, 4> hueRandomOffsets; //!< Per-preset constant offsets for the hue animation
 
-    projectm_eval_mem_buffer globalMemory{nullptr}; //!< gmegabuf data. Using per-frame buffers in projectM to reduce interference.
-    double globalRegisters[100]{}; //!< Global reg00-reg99 variables.
+    projectm_eval_mem_buffer globalMemory{nullptr};  //!< gmegabuf data. Using per-frame buffers in projectM to reduce interference.
+    double globalRegisters[100]{};                   //!< Global reg00-reg99 variables.
     std::array<double, QVarCount> frameQVariables{}; //!< Q variables after per-frame code evaluation.
 
     libprojectM::Audio::FrameAudioData audioData; //!< Holds audio/spectrum data and values for beat detection.
-    RenderContext renderContext; //!< Current renderer state data like viewport size and generic shaders.
+    Renderer::RenderContext renderContext;        //!< Current renderer state data like viewport size and generic shaders.
 
     std::string perFrameInitCode; //!< Preset init code, run once on load.
-    std::string perFrameCode; //!< Preset per-frame code, run once at the start of each frame.
-    std::string perPixelCode; //!< Preset per-pixel/per-vertex code, run once per warp mesh vertex.
+    std::string perFrameCode;     //!< Preset per-frame code, run once at the start of each frame.
+    std::string perPixelCode;     //!< Preset per-pixel/per-vertex code, run once per warp mesh vertex.
 
-    std::array<std::string, CustomWaveformCount> customWaveInitCode; //!< Custom wave init code, run once on load.
+    std::array<std::string, CustomWaveformCount> customWaveInitCode;     //!< Custom wave init code, run once on load.
     std::array<std::string, CustomWaveformCount> customWavePerFrameCode; //!< Custom wave per-frame code, run once after the per-frame code.
     std::array<std::string, CustomWaveformCount> customWavePerPointCode; //!< Custom wave per-point code, run once per waveform vertex.
 
-    std::array<std::string, CustomShapeCount> customShapeInitCode; //!< Custom shape init code, run once on load.
+    std::array<std::string, CustomShapeCount> customShapeInitCode;     //!< Custom shape init code, run once on load.
     std::array<std::string, CustomShapeCount> customShapePerFrameCode; //!< Custom shape per-frame code, run once per shape instance.
 
-    std::string warpShader; //!< Warp shader code.
+    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.
+    Renderer::Shader untexturedShader; //!< Shader used to draw untextured primitives, e.g. waveforms.
+    Renderer::Shader texturedShader;   //!< Shader used to draw textured primitives, e.g. textured shapes and the warp mesh.
 
-    std::weak_ptr<Texture> mainTexture; //!< A weak reference to the main texture in the preset framebuffer.
-    BlurTexture blurTexture; //!< The blur textures used in this preset. Contents depend on the shader code using GetBlurX().
+    std::weak_ptr<Renderer::Texture> mainTexture; //!< A weak reference to the main texture in the preset framebuffer.
+    BlurTexture blurTexture;                      //!< The blur textures used in this preset. Contents depend on the shader code using GetBlurX().
 
-    std::map<int, TextureSamplerDescriptor> randomTextureDescriptors; //!< Descriptors for random texture IDs. Should be the same across both warp and comp shaders.
+    std::map<int, Renderer::TextureSamplerDescriptor> randomTextureDescriptors; //!< Descriptors for random texture IDs. Should be the same across both warp and comp shaders.
 
-    static const glm::mat4 orthogonalProjection; //!< Projection matrix that transforms DirectX screen-space coordinates into the OpenGL coordinate frame.
+    static const glm::mat4 orthogonalProjection;        //!< Projection matrix that transforms DirectX screen-space coordinates into the OpenGL coordinate frame.
     static const glm::mat4 orthogonalProjectionFlipped; //!< Projection matrix that transforms DirectX screen-space coordinates into the OpenGL coordinate frame.
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/ShapePerFrameContext.cpp b/src/libprojectM/MilkdropPreset/ShapePerFrameContext.cpp
index 8476e493b..fe804de9e 100644
--- a/src/libprojectM/MilkdropPreset/ShapePerFrameContext.cpp
+++ b/src/libprojectM/MilkdropPreset/ShapePerFrameContext.cpp
@@ -11,6 +11,9 @@
 #define REG_VAR(var) \
     var = projectm_eval_context_register_variable(perFrameCodeContext, #var);
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 ShapePerFrameContext::ShapePerFrameContext(projectm_eval_mem_buffer gmegabuf, PRJM_EVAL_F (*globalRegisters)[100])
     : perFrameCodeContext(projectm_eval_context_create(gmegabuf, globalRegisters))
 {
@@ -191,3 +194,6 @@ void ShapePerFrameContext::ExecutePerFrameCode()
         projectm_eval_code_execute(perFrameCodeHandle);
     }
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/ShapePerFrameContext.hpp b/src/libprojectM/MilkdropPreset/ShapePerFrameContext.hpp
index 939f56dc8..2f13200d0 100644
--- a/src/libprojectM/MilkdropPreset/ShapePerFrameContext.hpp
+++ b/src/libprojectM/MilkdropPreset/ShapePerFrameContext.hpp
@@ -2,8 +2,10 @@
 
 #include "PresetState.hpp"
 
-class PerFrameContext;
+namespace libprojectM {
+namespace MilkdropPreset {
 
+class PerFrameContext;
 class CustomShape;
 
 class ShapePerFrameContext
@@ -95,3 +97,6 @@ public:
     double* tex_zoom{};
     double* tex_ang{};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.cpp b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
index aeb63c7d6..11d7dbd08 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.cpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
@@ -2,6 +2,9 @@
 
 #include <glm/gtc/type_ptr.hpp>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 VideoEcho::VideoEcho(const PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
@@ -95,12 +98,12 @@ void VideoEcho::Draw()
 
     glDisable(GL_BLEND);
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 
     if (mainTexture)
     {
         mainTexture->Unbind(0);
-        Sampler::Unbind(0);
+        Renderer::Sampler::Unbind(0);
     }
 }
 
@@ -240,3 +243,6 @@ void VideoEcho::DrawGammaAdjustment()
         }
     }
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.hpp b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
index e723a399d..e8f0f2194 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.hpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
@@ -7,10 +7,13 @@
 
 #include <Renderer/RenderItem.hpp>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 /**
  * @brief Renders a video "echo" (ghost image) effect and gamma adjustments.
  */
-class VideoEcho: public RenderItem
+class VideoEcho: public Renderer::RenderItem
 {
 public:
 	VideoEcho() = delete;
@@ -29,5 +32,8 @@ private:
 
     std::array<std::array<float, 3>, 4> m_shade; // !< Random, changing color values for the four corners
     std::array<TexturedPoint, 4> m_vertices; //!< The video echo/gamma adj mesh
-    Sampler m_sampler{GL_CLAMP_TO_EDGE, GL_LINEAR};
+    Renderer::Sampler m_sampler{GL_CLAMP_TO_EDGE, GL_LINEAR};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/Waveform.cpp b/src/libprojectM/MilkdropPreset/Waveform.cpp
index eedea8266..9db83ca42 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.cpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.cpp
@@ -11,6 +11,11 @@
 
 #include <cmath>
 
+using libprojectM::Renderer::RenderItem;
+
+namespace libprojectM {
+namespace MilkdropPreset {
+
 Waveform::Waveform(PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
@@ -124,7 +129,7 @@ void Waveform::Draw(const PerFrameContext& presetPerFrameContext)
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindVertexArray(0);
 
-    Shader::Unbind();
+    Renderer::Shader::Unbind();
 }
 
 void Waveform::ModulateOpacityByVolume(const PerFrameContext& presetPerFrameContext)
@@ -611,3 +616,6 @@ int Waveform::SmoothWave(const RenderItem::Point* inputVertices,
 
     return outputIndex + 1;
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/Waveform.hpp b/src/libprojectM/MilkdropPreset/Waveform.hpp
index 07b52eeea..dfd4029ea 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.hpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.hpp
@@ -4,8 +4,12 @@
 
 #include "Renderer/RenderItem.hpp"
 
-class PresetState;
+#include <vector>
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
+class PresetState;
 class PerFrameContext;
 
 class Waveform : public RenderItem
@@ -61,3 +65,6 @@ private:
     Point* m_wave1Vertices{nullptr};
     Point* m_wave2Vertices{nullptr};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.cpp b/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.cpp
index 35bc9ea26..e18133290 100644
--- a/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.cpp
+++ b/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.cpp
@@ -11,6 +11,9 @@
 #define REG_VAR(var) \
     var = projectm_eval_context_register_variable(perFrameCodeContext, #var);
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 WaveformPerFrameContext::WaveformPerFrameContext(projectm_eval_mem_buffer gmegabuf, PRJM_EVAL_F (*globalRegisters)[100])
     : perFrameCodeContext(projectm_eval_context_create(gmegabuf, globalRegisters))
 {
@@ -151,3 +154,6 @@ void WaveformPerFrameContext::ExecutePerFrameCode()
         projectm_eval_code_execute(perFrameCodeHandle);
     }
 }
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.hpp b/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.hpp
index 82db83906..9993f042d 100644
--- a/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.hpp
+++ b/src/libprojectM/MilkdropPreset/WaveformPerFrameContext.hpp
@@ -2,8 +2,10 @@
 
 #include "PresetState.hpp"
 
-class PerFrameContext;
+namespace libprojectM {
+namespace MilkdropPreset {
 
+class PerFrameContext;
 class CustomWaveform;
 
 class WaveformPerFrameContext
@@ -73,3 +75,6 @@ public:
     PRJM_EVAL_F* a{};
     PRJM_EVAL_F* samples{};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp b/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp
index f7bfaeb4e..5e775dc8a 100644
--- a/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp
+++ b/src/libprojectM/MilkdropPreset/WaveformPerPointContext.cpp
@@ -11,6 +11,9 @@
 #define REG_VAR(var) \
     var = projectm_eval_context_register_variable(perPointCodeContext, #var);
 
+namespace libprojectM {
+namespace MilkdropPreset {
+
 WaveformPerPointContext::WaveformPerPointContext(projectm_eval_mem_buffer gmegabuf, PRJM_EVAL_F (*globalRegisters)[100])
     : perPointCodeContext(projectm_eval_context_create(gmegabuf, globalRegisters))
 {
@@ -111,4 +114,7 @@ void WaveformPerPointContext::ExecutePerPointCode()
     {
         projectm_eval_code_execute(perPointCodeHandle);
     }
-}
\ No newline at end of file
+}
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/WaveformPerPointContext.hpp b/src/libprojectM/MilkdropPreset/WaveformPerPointContext.hpp
index ee72329a4..7f28ef88b 100644
--- a/src/libprojectM/MilkdropPreset/WaveformPerPointContext.hpp
+++ b/src/libprojectM/MilkdropPreset/WaveformPerPointContext.hpp
@@ -2,8 +2,10 @@
 
 #include "PresetState.hpp"
 
-class CustomWaveform;
+namespace libprojectM {
+namespace MilkdropPreset {
 
+class CustomWaveform;
 class PerFrameContext;
 
 class WaveformPerPointContext
@@ -68,3 +70,6 @@ public:
     PRJM_EVAL_F* b{};
     PRJM_EVAL_F* a{};
 };
+
+} // namespace MilkdropPreset
+} // namespace libprojectM
diff --git a/src/libprojectM/Preset.hpp b/src/libprojectM/Preset.hpp
index 0d7ca407e..b1cb433c1 100644
--- a/src/libprojectM/Preset.hpp
+++ b/src/libprojectM/Preset.hpp
@@ -7,6 +7,7 @@
 
 #include <string>
 
+namespace libprojectM {
 
 class Preset
 {
@@ -17,7 +18,7 @@ public:
      * @brief Initializes additional preset resources.
      * @param renderContext A render context with the initial data.
      */
-    virtual void Initialize(const RenderContext& renderContext) = 0;
+    virtual void Initialize(const Renderer::RenderContext& renderContext) = 0;
 
     /**
      * @brief Renders the preset into the current framebuffer.
@@ -25,7 +26,7 @@ public:
      * @param renderContext The current render context data.
      */
     virtual void RenderFrame(const libprojectM::Audio::FrameAudioData& audioData,
-                             const RenderContext& renderContext) = 0;
+                             const Renderer::RenderContext& renderContext) = 0;
 
     /**
      * @brief Returns a pointer to the current rendering output texture.
@@ -33,7 +34,7 @@ public:
      * across multiple frames. Instead, a new pointer should be requested whenever needed.
      * @return A pointer to the current output texture of the preset.
      */
-    virtual auto OutputTexture() const -> std::shared_ptr<Texture> = 0;
+    virtual auto OutputTexture() const -> std::shared_ptr<Renderer::Texture> = 0;
 
     /**
      * @brief Draws an initial image into the preset, e.g. the last frame of a previous preset.
@@ -42,8 +43,8 @@ public:
      * @param image The texture to be copied as the initial preset image.
      * @param renderContext The current render context data.
      */
-    virtual void DrawInitialImage(const std::shared_ptr<Texture>& image,
-                                  const RenderContext& renderContext) {};
+    virtual void DrawInitialImage(const std::shared_ptr<Renderer::Texture>& image,
+                                  const Renderer::RenderContext& renderContext) {};
 
     inline void SetFilename(const std::string& filename)
     {
@@ -58,3 +59,5 @@ public:
 private:
     std::string m_filename;
 };
+
+} // namespace libprojectM
diff --git a/src/libprojectM/PresetFactory.cpp b/src/libprojectM/PresetFactory.cpp
index 2fe73e514..bc6e2f317 100644
--- a/src/libprojectM/PresetFactory.cpp
+++ b/src/libprojectM/PresetFactory.cpp
@@ -4,6 +4,8 @@
 #include <iostream>
 #endif
 
+namespace libprojectM {
+
 const std::string PresetFactory::IDLE_PRESET_PROTOCOL("idle");
 
 std::string PresetFactory::Protocol(const std::string& url, std::string& path)
@@ -22,3 +24,5 @@ std::string PresetFactory::Protocol(const std::string& url, std::string& path)
 #endif
     return url.substr(0, pos);
 }
+
+} // namespace libprojectM
diff --git a/src/libprojectM/PresetFactory.hpp b/src/libprojectM/PresetFactory.hpp
index 370b1f540..bc5847e7d 100644
--- a/src/libprojectM/PresetFactory.hpp
+++ b/src/libprojectM/PresetFactory.hpp
@@ -4,6 +4,8 @@
 
 #include <memory>
 
+namespace libprojectM {
+
 class PresetFactory
 {
 
@@ -47,3 +49,5 @@ public:
      */
     virtual std::string supportedExtensions() const = 0;
 };
+
+} // namespace libprojectM
diff --git a/src/libprojectM/PresetFactoryManager.cpp b/src/libprojectM/PresetFactoryManager.cpp
index 6db294abd..d74e3c526 100644
--- a/src/libprojectM/PresetFactoryManager.cpp
+++ b/src/libprojectM/PresetFactoryManager.cpp
@@ -11,13 +11,15 @@
 //
 #include "PresetFactoryManager.hpp"
 
-#include <MilkdropPreset/MilkdropPresetFactory.hpp>
+#include <MilkdropPreset/Factory.hpp>
 
 #include <algorithm>
 #include <cassert>
 #include <iostream>
 #include <sstream>
 
+namespace libprojectM {
+
 PresetFactoryManager::~PresetFactoryManager()
 {
     ClearFactories();
@@ -39,7 +41,7 @@ void PresetFactoryManager::initialize()
 {
     ClearFactories();
 
-    auto* milkdropFactory = new MilkdropPresetFactory();
+    auto* milkdropFactory = new MilkdropPreset::Factory();
     registerFactory(milkdropFactory->supportedExtensions(), milkdropFactory);
 }
 
@@ -148,3 +150,5 @@ auto PresetFactoryManager::ParseExtension(const std::string& filename) -> std::s
     std::transform(ext.begin(), ext.end(), ext.begin(), tolower);
     return ext;
 }
+
+} // namespace libprojectM
diff --git a/src/libprojectM/PresetFactoryManager.hpp b/src/libprojectM/PresetFactoryManager.hpp
index 49154d497..2b4363033 100644
--- a/src/libprojectM/PresetFactoryManager.hpp
+++ b/src/libprojectM/PresetFactoryManager.hpp
@@ -6,6 +6,8 @@
 #include <utility>
 #include <vector>
 
+namespace libprojectM {
+
 /// A simple exception class to strongly type all preset factory related issues
 class PresetFactoryException : public std::exception
 {
@@ -86,3 +88,5 @@ private:
     mutable std::vector<PresetFactory*> m_factoryList;
     void ClearFactories();
 };
+
+} // namespace libprojectM
diff --git a/src/libprojectM/ProjectM.cpp b/src/libprojectM/ProjectM.cpp
index 799a99639..8f344d0cb 100644
--- a/src/libprojectM/ProjectM.cpp
+++ b/src/libprojectM/ProjectM.cpp
@@ -32,13 +32,12 @@
 #include "Renderer/TextureManager.hpp"
 #include "Renderer/TransitionShaderManager.hpp"
 
-
 #if PROJECTM_USE_THREADS
-
 #include "libprojectM/BackgroundWorker.hpp"
-
 #endif
 
+namespace libprojectM {
+
 ProjectM::ProjectM()
     : m_presetFactoryManager(std::make_unique<PresetFactoryManager>())
 #if PROJECTM_USE_THREADS
@@ -106,12 +105,12 @@ void ProjectM::LoadPresetData(std::istream& presetData, bool smoothTransition)
 void ProjectM::SetTexturePaths(std::vector<std::string> texturePaths)
 {
     m_textureSearchPaths = std::move(texturePaths);
-    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
+    m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
 }
 
 void ProjectM::ResetTextures()
 {
-    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
+    m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
 }
 
 void ProjectM::DumpDebugImageOnNextFrame(const std::string& outputFile)
@@ -248,11 +247,11 @@ void ProjectM::Initialize()
 
     /** Initialise per-pixel matrix calculations */
     /** We need to initialise this before the builtin param db otherwise bass/mid etc won't bind correctly */
-    m_textureManager = std::make_unique<TextureManager>(m_textureSearchPaths);
+    m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
 
-    m_transitionShaderManager = std::make_unique<TransitionShaderManager>();
+    m_transitionShaderManager = std::make_unique<Renderer::TransitionShaderManager>();
 
-    m_textureCopier = std::make_unique<CopyTexture>();
+    m_textureCopier = std::make_unique<Renderer::CopyTexture>();
 
     m_presetFactoryManager->initialize();
 
@@ -319,7 +318,7 @@ void ProjectM::StartPresetTransition(std::unique_ptr<Preset>&& preset, bool hard
     {
         m_transitioningPreset = std::move(preset);
         m_timeKeeper->StartSmoothing();
-        m_transition = std::make_unique<PresetTransition>(m_transitionShaderManager->RandomTransition(), m_softCutDuration);
+        m_transition = std::make_unique<Renderer::PresetTransition>(m_transitionShaderManager->RandomTransition(), m_softCutDuration);
     }
 }
 
@@ -487,9 +486,9 @@ void ProjectM::TouchDestroyAll()
 {
 }
 
-auto ProjectM::GetRenderContext() -> RenderContext
+auto ProjectM::GetRenderContext() -> Renderer::RenderContext
 {
-    RenderContext ctx{};
+    Renderer::RenderContext ctx{};
     ctx.viewportSizeX = m_windowWidth;
     ctx.viewportSizeY = m_windowHeight;
     ctx.time = static_cast<float>(m_timeKeeper->GetRunningTime());
@@ -506,3 +505,5 @@ auto ProjectM::GetRenderContext() -> RenderContext
 
     return ctx;
 }
+
+} // namespace libprojectM
diff --git a/src/libprojectM/ProjectM.hpp b/src/libprojectM/ProjectM.hpp
index bf5cae969..219883602 100644
--- a/src/libprojectM/ProjectM.hpp
+++ b/src/libprojectM/ProjectM.hpp
@@ -47,29 +47,25 @@
 
 #endif
 
+namespace libprojectM {
+
 class BackgroundWorkerSync;
 
-namespace libprojectM {
 namespace Audio {
 class BeatDetect;
-}
-} // namespace libprojectM
-
-class Renderer;
-
-class TextureManager;
-
-class TransitionShaderManager;
+} // namespace Audio
 
+namespace Renderer {
 class CopyTexture;
+class PresetTransition;
+class Renderer;
+class TextureManager;
+class TransitionShaderManager;
+} // namespace Renderer
 
 class Preset;
-
-class PresetTransition;
-
-class TimeKeeper;
-
 class PresetFactoryManager;
+class TimeKeeper;
 
 class PROJECTM_EXPORT ProjectM
 {
@@ -196,7 +192,7 @@ public:
     /// Returns true if the active preset is locked
     auto PresetLocked() const -> bool;
 
-    auto PCM() -> libprojectM::Audio::PCM&;
+    auto PCM() -> Audio::PCM&;
 
     auto WindowWidth() -> int;
 
@@ -216,7 +212,7 @@ private:
 
     void LoadIdlePreset();
 
-    auto GetRenderContext() -> RenderContext;
+    auto GetRenderContext() -> Renderer::RenderContext;
 
 #if PROJECTM_USE_THREADS
 
@@ -250,14 +246,14 @@ private:
 
     std::unique_ptr<PresetFactoryManager> m_presetFactoryManager; //!< Provides access to all available preset factories.
 
-    libprojectM::Audio::PCM m_audioStorage;                             //!< Audio data buffer and analyzer instance.
-    std::unique_ptr<TextureManager> m_textureManager;                   //!< The texture manager.
-    std::unique_ptr<TransitionShaderManager> m_transitionShaderManager; //!< The transition shader manager.
-    std::unique_ptr<CopyTexture> m_textureCopier;                       //!< Class that copies textures 1:1 to another texture or framebuffer.
-    std::unique_ptr<Preset> m_activePreset;                             //!< Currently loaded preset.
-    std::unique_ptr<Preset> m_transitioningPreset;                      //!< Destination preset when smooth preset switching.
-    std::unique_ptr<PresetTransition> m_transition;                     //!< Transition effect used for blending.
-    std::unique_ptr<TimeKeeper> m_timeKeeper;                           //!< Keeps the different timers used to render and switch presets.
+    Audio::PCM m_audioStorage;                                                    //!< Audio data buffer and analyzer instance.
+    std::unique_ptr<Renderer::TextureManager> m_textureManager;                   //!< The texture manager.
+    std::unique_ptr<Renderer::TransitionShaderManager> m_transitionShaderManager; //!< The transition shader manager.
+    std::unique_ptr<Renderer::CopyTexture> m_textureCopier;                       //!< Class that copies textures 1:1 to another texture or framebuffer.
+    std::unique_ptr<Preset> m_activePreset;                                       //!< Currently loaded preset.
+    std::unique_ptr<Preset> m_transitioningPreset;                                //!< Destination preset when smooth preset switching.
+    std::unique_ptr<Renderer::PresetTransition> m_transition;                     //!< Transition effect used for blending.
+    std::unique_ptr<TimeKeeper> m_timeKeeper;                                     //!< Keeps the different timers used to render and switch presets.
 
 #if PROJECTM_USE_THREADS
     mutable std::recursive_mutex m_presetSwitchMutex;   //!< Mutex for locking preset switching while rendering and vice versa.
@@ -265,3 +261,5 @@ private:
     std::unique_ptr<BackgroundWorkerSync> m_workerSync; //!< Background work synchronizer.
 #endif
 };
+
+} // namespace libprojectM
diff --git a/src/libprojectM/ProjectMCWrapper.cpp b/src/libprojectM/ProjectMCWrapper.cpp
index 3baabe5fd..11957751e 100644
--- a/src/libprojectM/ProjectMCWrapper.cpp
+++ b/src/libprojectM/ProjectMCWrapper.cpp
@@ -7,6 +7,8 @@
 #include <cstring>
 #include <sstream>
 
+namespace libprojectM {
+
 void projectMWrapper::PresetSwitchRequestedEvent(bool isHardCut) const
 {
     if (m_presetSwitchRequestedEventCallback)
@@ -25,9 +27,11 @@ void projectMWrapper::PresetSwitchFailedEvent(const std::string& presetFilename,
     }
 }
 
-projectMWrapper* handle_to_instance(projectm_handle instance)
+} // namespace libprojectM
+
+libprojectM::projectMWrapper* handle_to_instance(projectm_handle instance)
 {
-    return reinterpret_cast<projectMWrapper*>(instance);
+    return reinterpret_cast<libprojectM::projectMWrapper*>(instance);
 }
 
 char* projectm_alloc_string(unsigned int length)
@@ -61,7 +65,7 @@ projectm_handle projectm_create()
 {
     try
     {
-        auto projectMInstance = new projectMWrapper();
+        auto projectMInstance = new libprojectM::projectMWrapper();
         return reinterpret_cast<projectm_handle>(projectMInstance);
     }
     catch (...)
diff --git a/src/libprojectM/ProjectMCWrapper.hpp b/src/libprojectM/ProjectMCWrapper.hpp
index dc762c740..ccca3e33c 100644
--- a/src/libprojectM/ProjectMCWrapper.hpp
+++ b/src/libprojectM/ProjectMCWrapper.hpp
@@ -25,6 +25,8 @@
 
 #include "projectM-4/projectM.h"
 
+namespace libprojectM {
+
 class projectMWrapper : public ProjectM
 {
 public:
@@ -38,3 +40,5 @@ public:
     projectm_preset_switch_requested_event m_presetSwitchRequestedEventCallback{nullptr};
     void* m_presetSwitchRequestedEventUserData{nullptr};
 };
+
+} // namespace libprojectM
diff --git a/src/libprojectM/RandomNumberGenerators.hpp b/src/libprojectM/RandomNumberGenerators.hpp
index 15256d15f..ad4de6925 100644
--- a/src/libprojectM/RandomNumberGenerators.hpp
+++ b/src/libprojectM/RandomNumberGenerators.hpp
@@ -1,5 +1,5 @@
-#ifndef RANDOM_NUMBER_GENERATORS_HPP
-#define RANDOM_NUMBER_GENERATORS_HPP
+#pragma once
+
 #include <cmath>
 #include <vector>
 #include <cassert>
@@ -7,6 +7,7 @@
 
 #define WEIGHTED_RANDOM_DEBUG 0
 
+namespace libprojectM {
 namespace RandomNumberGenerators {
 
 inline double uniform()
@@ -117,5 +118,5 @@ inline std::size_t weightedRandom(const std::vector<int> & weights, unsigned int
 	return weights.size()-1;
 }
 
-}
-#endif
+} // namespace RandomNumberGenerators
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/CopyTexture.cpp b/src/libprojectM/Renderer/CopyTexture.cpp
index 7deefb609..c56f799b8 100644
--- a/src/libprojectM/Renderer/CopyTexture.cpp
+++ b/src/libprojectM/Renderer/CopyTexture.cpp
@@ -3,6 +3,10 @@
 #include <array>
 #include <iostream>
 
+
+namespace libprojectM {
+namespace Renderer {
+
 #ifdef USE_GLES
 static constexpr char ShaderVersion[] = "#version 300 es\n\n";
 #else
@@ -218,3 +222,6 @@ void CopyTexture::Copy(bool flipVertical, bool flipHorizontal) const
     Sampler::Unbind(0);
     Shader::Unbind();
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/CopyTexture.hpp b/src/libprojectM/Renderer/CopyTexture.hpp
index d0527181c..e8911d3ca 100644
--- a/src/libprojectM/Renderer/CopyTexture.hpp
+++ b/src/libprojectM/Renderer/CopyTexture.hpp
@@ -4,6 +4,9 @@
 #include "Renderer/RenderItem.hpp"
 #include "Renderer/Shader.hpp"
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @class CopyTexture
  * @brief Copies the given input texture to an output texture or framebuffer.
@@ -72,3 +75,6 @@ private:
     int m_width{};  //!< Last known framebuffer/texture width
     int m_height{}; //!< Last known framebuffer/texture height
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/FileScanner.cpp b/src/libprojectM/Renderer/FileScanner.cpp
index 63243f212..28b933d95 100644
--- a/src/libprojectM/Renderer/FileScanner.cpp
+++ b/src/libprojectM/Renderer/FileScanner.cpp
@@ -6,16 +6,23 @@
 
 #include "FileScanner.hpp"
 
-/** Per-platform path separators and includes */
-#ifdef _WIN32
-char constexpr pathSeparator{'\\'};
-#else
-char constexpr pathSeparator{'/'};
+#include <algorithm>
+#include <cstring>
+
+#ifndef _WIN32
 #include <sys/stat.h>
 #include <sys/types.h>
 #endif
 
-#include <algorithm>
+/* Per-platform path separators */
+#ifndef _WIN32
+char constexpr pathSeparator{'\\'};
+#else
+char constexpr pathSeparator{'/'};
+#endif
+
+namespace libprojectM {
+namespace Renderer {
 
 FileScanner::FileScanner()
 {
@@ -107,14 +114,14 @@ void FileScanner::scanGeneric(ScanCallback cb, const char* currentDir)
     DIR* m_dir;
 
     // Allocate a new a stream given the current directory name
-    if ((m_dir = opendir(currentDir)) == NULL)
+    if ((m_dir = opendir(currentDir)) == nullptr)
     {
         return; // no files found in here
     }
 
     struct dirent* dir_entry;
 
-    while ((dir_entry = readdir(m_dir)) != NULL)
+    while ((dir_entry = readdir(m_dir)) != nullptr)
     {
         // Convert char * to friendly string
         std::string filename(dir_entry->d_name);
@@ -172,7 +179,7 @@ void FileScanner::scanGeneric(ScanCallback cb, const char* currentDir)
 // more optimized posix "fts" directory traversal
 int fts_compare(const FTSENT** one, const FTSENT** two)
 {
-    return (strcmp((*one)->fts_name, (*two)->fts_name));
+    return (std::strcmp((*one)->fts_name, (*two)->fts_name));
 }
 #endif
 
@@ -181,8 +188,8 @@ void FileScanner::scanPosix(ScanCallback cb)
 #if HAVE_FTS_H
 
     // efficient directory traversal
-    FTS* fileSystem = NULL;
-    FTSENT* node = NULL;
+    FTS* fileSystem = nullptr;
+    FTSENT* node = nullptr;
 
     if (_rootDirs.empty())
     {
@@ -197,11 +204,11 @@ void FileScanner::scanPosix(ScanCallback cb)
     {
         dirList[i] = (char*) _rootDirs[i].c_str();
     }
-    dirList[rootDirCount] = NULL;
+    dirList[rootDirCount] = nullptr;
 
     // initialize file hierarchy traversal
     fileSystem = fts_open(dirList, FTS_LOGICAL | FTS_NOCHDIR | FTS_NOSTAT, &fts_compare);
-    if (fileSystem == NULL)
+    if (fileSystem == nullptr)
     {
         std::string s;
         for (std::size_t i = 0; i < _rootDirs.size(); i++)
@@ -215,7 +222,7 @@ void FileScanner::scanPosix(ScanCallback cb)
     std::string path, name, nameMatched;
 
     // traverse dirList
-    while ((node = fts_read(fileSystem)) != NULL)
+    while ((node = fts_read(fileSystem)) != nullptr)
     {
         switch (node->fts_info)
         {
@@ -247,3 +254,6 @@ void FileScanner::scanPosix(ScanCallback cb)
 
 #endif
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/FileScanner.hpp b/src/libprojectM/Renderer/FileScanner.hpp
index 807184afd..602d32aa3 100644
--- a/src/libprojectM/Renderer/FileScanner.hpp
+++ b/src/libprojectM/Renderer/FileScanner.hpp
@@ -1,17 +1,9 @@
-//
-//  FileScanner.hpp
-//  libprojectM
-//
-//  Cross-platform directory traversal with filtering by extension
-
-#ifndef FileScanner_hpp
-#define FileScanner_hpp
+#pragma once
 
+#include <functional>
+#include <iostream>
 #include <string>
 #include <vector>
-#include <iostream>
-#include <functional>
-#include <string.h>
 
 #if HAVE_FTS_H
 #include <fts.h>
@@ -24,6 +16,9 @@ extern "C"
 #include "dirent.h"
 #endif
 
+namespace libprojectM {
+namespace Renderer {
+
 typedef std::function<void(std::string &path, std::string &name)> ScanCallback;
 
 class FileScanner
@@ -45,4 +40,5 @@ private:
 	bool isValidFilename(std::string &filename);
 };
 
-#endif /* FileScanner_hpp */
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Framebuffer.cpp b/src/libprojectM/Renderer/Framebuffer.cpp
index 0239c8811..73e3bc99c 100644
--- a/src/libprojectM/Renderer/Framebuffer.cpp
+++ b/src/libprojectM/Renderer/Framebuffer.cpp
@@ -1,6 +1,7 @@
 #include "Framebuffer.hpp"
 
-#include <cassert>
+namespace libprojectM {
+namespace Renderer {
 
 Framebuffer::Framebuffer()
 {
@@ -398,3 +399,5 @@ void Framebuffer::RemoveAttachment(int framebufferIndex, GLenum attachmentType)
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_framebufferIds.at(m_drawFramebuffer));
 }
 
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Framebuffer.hpp b/src/libprojectM/Renderer/Framebuffer.hpp
index cebf7e5e6..0d75b9038 100644
--- a/src/libprojectM/Renderer/Framebuffer.hpp
+++ b/src/libprojectM/Renderer/Framebuffer.hpp
@@ -11,6 +11,9 @@
 #include <map>
 #include <vector>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief A framebuffer class holding one or more framebuffer objects.
  *
@@ -238,3 +241,6 @@ private:
     int m_readFramebuffer{}; //!< Index of the framebuffer currently being read.
     int m_drawFramebuffer{}; //!< Index of the framebuffer currently being drawn to.
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/IdleTextures.hpp b/src/libprojectM/Renderer/IdleTextures.hpp
index 7efcac943..fa9927cb4 100644
--- a/src/libprojectM/Renderer/IdleTextures.hpp
+++ b/src/libprojectM/Renderer/IdleTextures.hpp
@@ -1,3 +1,7 @@
+#pragma once
+
+namespace libprojectM {
+namespace Renderer {
 
 /* begin binary data: */
 const int M_bytes = 27965;
@@ -5983,3 +5987,5 @@ const unsigned char headphones_data[] = /* 22402 */
 ,0x58,0x46,0x49,0x4C,0x45,0x2E,0x00};
 /* end binary data. size = 22402 bytes */
 
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/MilkdropNoise.cpp b/src/libprojectM/Renderer/MilkdropNoise.cpp
index 84da34051..3126192e6 100644
--- a/src/libprojectM/Renderer/MilkdropNoise.cpp
+++ b/src/libprojectM/Renderer/MilkdropNoise.cpp
@@ -3,6 +3,9 @@
 #include <chrono>
 #include <random>
 
+namespace libprojectM {
+namespace Renderer {
+
 MilkdropNoise::MilkdropNoise()
 {
     generate2D(256, 1, &noise_lq);
@@ -266,3 +269,6 @@ uint32_t MilkdropNoise::dwCubicInterpolate(uint32_t y0, uint32_t y1, uint32_t y2
     }
     return ret;
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/MilkdropNoise.hpp b/src/libprojectM/Renderer/MilkdropNoise.hpp
index 0c8625708..08fb473a0 100644
--- a/src/libprojectM/Renderer/MilkdropNoise.hpp
+++ b/src/libprojectM/Renderer/MilkdropNoise.hpp
@@ -3,6 +3,9 @@
 #include <cstdint>
 #include <vector>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Implementation of Milkdrop's noise texture generator.
  *
@@ -68,4 +71,5 @@ protected:
     static uint32_t dwCubicInterpolate(uint32_t y0, uint32_t y1, uint32_t y2, uint32_t y3, float t);
 };
 
-
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/PresetTransition.cpp b/src/libprojectM/Renderer/PresetTransition.cpp
index 8fa903f3f..2a27f0021 100644
--- a/src/libprojectM/Renderer/PresetTransition.cpp
+++ b/src/libprojectM/Renderer/PresetTransition.cpp
@@ -6,6 +6,9 @@
 #include <cmath>
 #include <cstddef>
 
+namespace libprojectM {
+namespace Renderer {
+
 constexpr double PI = 3.14159265358979323846;
 
 PresetTransition::PresetTransition(const std::shared_ptr<Shader>& transitionShader, double durationSeconds)
@@ -129,3 +132,6 @@ void PresetTransition::Draw(const Preset& oldPreset,
     // Update last frame time.
     m_lastFrameTime = std::chrono::system_clock::now();
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/PresetTransition.hpp b/src/libprojectM/Renderer/PresetTransition.hpp
index af181ac2a..e5bcb416a 100644
--- a/src/libprojectM/Renderer/PresetTransition.hpp
+++ b/src/libprojectM/Renderer/PresetTransition.hpp
@@ -11,6 +11,9 @@
 #include <chrono>
 #include <random>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Implements the shader and rendering logic to blend two presets into each other.
  */
@@ -64,3 +67,6 @@ private:
 
     std::random_device m_randomDevice; //!< Seed for the random number generator
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/RenderContext.hpp b/src/libprojectM/Renderer/RenderContext.hpp
index 81b7741cd..1a14f5258 100644
--- a/src/libprojectM/Renderer/RenderContext.hpp
+++ b/src/libprojectM/Renderer/RenderContext.hpp
@@ -6,6 +6,9 @@
 
 #include "projectM-opengl.h"
 
+namespace libprojectM {
+namespace Renderer {
+
 class TextureManager;
 
 /**
@@ -30,3 +33,6 @@ public:
 
     TextureManager* textureManager{nullptr}; //!< Holds all loaded textures for shader access.
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/RenderItem.cpp b/src/libprojectM/Renderer/RenderItem.cpp
index 935a060e6..08b9bdcdc 100644
--- a/src/libprojectM/Renderer/RenderItem.cpp
+++ b/src/libprojectM/Renderer/RenderItem.cpp
@@ -1,5 +1,8 @@
 #include "RenderItem.hpp"
 
+namespace libprojectM {
+namespace Renderer {
+
 void RenderItem::Init()
 {
     glGenVertexArrays(1, &m_vaoID);
@@ -19,3 +22,6 @@ RenderItem::~RenderItem()
     glDeleteBuffers(1, &m_vboID);
     glDeleteVertexArrays(1, &m_vaoID);
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/RenderItem.hpp b/src/libprojectM/Renderer/RenderItem.hpp
index 12fe59271..faa0671d3 100644
--- a/src/libprojectM/Renderer/RenderItem.hpp
+++ b/src/libprojectM/Renderer/RenderItem.hpp
@@ -2,6 +2,9 @@
 
 #include "RenderContext.hpp"
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Base class for render meshes.
  * Also defines a few standard vertex attribute structures for use with the shaders.
@@ -74,3 +77,6 @@ protected:
     GLuint m_vboID{0}; //!< This RenderItem's vertex buffer object ID
     GLuint m_vaoID{0}; //!< This RenderItem's vertex array object ID
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Sampler.cpp b/src/libprojectM/Renderer/Sampler.cpp
index 082ef8558..b95ce270a 100644
--- a/src/libprojectM/Renderer/Sampler.cpp
+++ b/src/libprojectM/Renderer/Sampler.cpp
@@ -1,5 +1,8 @@
 #include "Sampler.hpp"
 
+namespace libprojectM {
+namespace Renderer {
+
 Sampler::Sampler(const GLint wrapMode, const GLint filterMode)
     : m_wrapMode(wrapMode)
     , m_filterMode(filterMode)
@@ -62,3 +65,6 @@ void Sampler::FilterMode(GLint filterMode)
     glSamplerParameteri(m_samplerId, GL_TEXTURE_MIN_FILTER, filterMode);
     glSamplerParameteri(m_samplerId, GL_TEXTURE_MAG_FILTER, filterMode);
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Sampler.hpp b/src/libprojectM/Renderer/Sampler.hpp
index 09550f1b9..e118bd863 100644
--- a/src/libprojectM/Renderer/Sampler.hpp
+++ b/src/libprojectM/Renderer/Sampler.hpp
@@ -8,6 +8,9 @@
 
 #include <memory>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Stores a single texture sampler.
  *
@@ -79,4 +82,7 @@ private:
     GLuint m_samplerId{0}; //!< the OpenGL Sampler name/ID.
     GLint m_wrapMode{0}; //!< The texture wrap mode.
     GLint m_filterMode{0}; //!< The texture filtering mode.
-};
\ No newline at end of file
+};
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Shader.cpp b/src/libprojectM/Renderer/Shader.cpp
index 7565baaaa..7cb171279 100644
--- a/src/libprojectM/Renderer/Shader.cpp
+++ b/src/libprojectM/Renderer/Shader.cpp
@@ -2,6 +2,9 @@
 
 #include <glm/gtc/type_ptr.hpp>
 
+namespace libprojectM {
+namespace Renderer {
+
 Shader::Shader()
     : m_shaderProgram(glCreateProgram())
 {
@@ -240,4 +243,7 @@ auto Shader::GetShaderLanguageVersion() -> Shader::GlslVersion
     int versionMinor = std::stoi(shaderLanguageVersionString.substr(dotPos + 1));
 
     return {versionMajor, versionMinor};
-}
\ No newline at end of file
+}
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Shader.hpp b/src/libprojectM/Renderer/Shader.hpp
index 56b6b2820..fd600bf66 100644
--- a/src/libprojectM/Renderer/Shader.hpp
+++ b/src/libprojectM/Renderer/Shader.hpp
@@ -15,6 +15,9 @@
 #include <map>
 #include <string>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Shader compilation exception.
  */
@@ -188,3 +191,6 @@ private:
 
     GLuint m_shaderProgram{}; //!< The program ID.
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Texture.cpp b/src/libprojectM/Renderer/Texture.cpp
index 67056893d..47fb59b30 100644
--- a/src/libprojectM/Renderer/Texture.cpp
+++ b/src/libprojectM/Renderer/Texture.cpp
@@ -2,6 +2,9 @@
 
 #include <utility>
 
+namespace libprojectM {
+namespace Renderer {
+
 Texture::Texture(std::string name, const int width, const int height, const bool isUserTexture)
     : m_target(GL_TEXTURE_2D)
     , m_name(std::move(name))
@@ -103,3 +106,6 @@ void Texture::CreateEmptyTexture()
     glTexImage2D(m_target, 0, m_internalFormat, m_width, m_height, 0, m_format, m_type, nullptr);
     glBindTexture(m_target, 0);
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Texture.hpp b/src/libprojectM/Renderer/Texture.hpp
index 5506e2b66..b0855ba20 100644
--- a/src/libprojectM/Renderer/Texture.hpp
+++ b/src/libprojectM/Renderer/Texture.hpp
@@ -10,6 +10,9 @@
 #include <string>
 #include <vector>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Stores a texture in the GPU and manages a few properties and the samplers.
  *
@@ -129,3 +132,6 @@ private:
     GLenum m_format{};        //!< OpenGL color format, e.g. GL_RGBA
     GLenum m_type{};          //!< OpenGL component storage type, e.g. GL_UNSIGNED _BYTE
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TextureAttachment.cpp b/src/libprojectM/Renderer/TextureAttachment.cpp
index 36754b70d..1c342ad4a 100644
--- a/src/libprojectM/Renderer/TextureAttachment.cpp
+++ b/src/libprojectM/Renderer/TextureAttachment.cpp
@@ -5,6 +5,9 @@
 #define GL_STENCIL_INDEX 0x1901
 #endif
 
+namespace libprojectM {
+namespace Renderer {
+
 TextureAttachment::TextureAttachment(AttachmentType attachment, int width, int height)
     : m_attachmentType(attachment)
 {
@@ -117,3 +120,6 @@ void TextureAttachment::ReplaceTexture(int width, int height)
 
     m_texture = std::make_shared<class Texture>("", textureId, GL_TEXTURE_2D, width, height, false);
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TextureAttachment.hpp b/src/libprojectM/Renderer/TextureAttachment.hpp
index 845c74ea0..27f8bfcb6 100644
--- a/src/libprojectM/Renderer/TextureAttachment.hpp
+++ b/src/libprojectM/Renderer/TextureAttachment.hpp
@@ -10,6 +10,9 @@
 
 #include <memory>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Framebuffer texture attachment. Stores the texture and attachment type.
  */
@@ -97,3 +100,6 @@ private:
     GLenum m_format{};        //!< OpenGL color format, e.g. GL_RGBA
     GLenum m_type{};          //!< OpenGL component storage type, e.g. GL_UNSIGNED _BYTE
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TextureManager.cpp b/src/libprojectM/Renderer/TextureManager.cpp
index 208d1cd70..c7851732d 100644
--- a/src/libprojectM/Renderer/TextureManager.cpp
+++ b/src/libprojectM/Renderer/TextureManager.cpp
@@ -19,6 +19,8 @@
 #define GL_TEXTURE_IMAGE_FORMAT 0x828F
 #endif
 
+namespace libprojectM {
+namespace Renderer {
 
 TextureManager::TextureManager(const std::vector<std::string>& textureSearchPaths)
     : m_textureSearchPaths(textureSearchPaths)
@@ -417,3 +419,6 @@ void TextureManager::ScanTextures()
         m_filesScanned = true;
     }
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TextureManager.hpp b/src/libprojectM/Renderer/TextureManager.hpp
index 110450121..0cafcfcc8 100644
--- a/src/libprojectM/Renderer/TextureManager.hpp
+++ b/src/libprojectM/Renderer/TextureManager.hpp
@@ -10,6 +10,8 @@
 #include <string>
 #include <vector>
 
+namespace libprojectM {
+namespace Renderer {
 
 class TextureManager
 {
@@ -104,3 +106,6 @@ private:
     std::vector<std::string> m_randomTextures;
     std::vector<std::string> m_extensions{".jpg", ".jpeg", ".dds", ".png", ".tga", ".bmp", ".dib"};
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TextureSamplerDescriptor.cpp b/src/libprojectM/Renderer/TextureSamplerDescriptor.cpp
index 52d9f41d8..75592c6fd 100644
--- a/src/libprojectM/Renderer/TextureSamplerDescriptor.cpp
+++ b/src/libprojectM/Renderer/TextureSamplerDescriptor.cpp
@@ -4,6 +4,9 @@
 
 #include <utility>
 
+namespace libprojectM {
+namespace Renderer {
+
 TextureSamplerDescriptor::TextureSamplerDescriptor(const std::shared_ptr<class Texture>& texture,
                                                    const std::shared_ptr<class Sampler>& sampler,
                                                    std::string samplerName,
@@ -141,4 +144,7 @@ void TextureSamplerDescriptor::TryUpdate(TextureManager& textureManager)
 
     m_texture = desc.m_texture;
     m_sampler = desc.m_sampler;
-}
\ No newline at end of file
+}
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TextureSamplerDescriptor.hpp b/src/libprojectM/Renderer/TextureSamplerDescriptor.hpp
index 07b5bc038..11901e688 100644
--- a/src/libprojectM/Renderer/TextureSamplerDescriptor.hpp
+++ b/src/libprojectM/Renderer/TextureSamplerDescriptor.hpp
@@ -4,6 +4,9 @@
 #include "Sampler.hpp"
 #include "Shader.hpp"
 
+namespace libprojectM {
+namespace Renderer {
+
 class TextureManager;
 
 /**
@@ -101,3 +104,6 @@ private:
     std::string m_sizeName; //!< The name of the "texsize_" uniform as referenced in the shader.
     bool m_updateFailed{false}; //!< Set to true if the update try failed, e.g. texture could not be loaded.
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TransitionShaderManager.cpp b/src/libprojectM/Renderer/TransitionShaderManager.cpp
index 3e5a9a780..d6bdf5415 100644
--- a/src/libprojectM/Renderer/TransitionShaderManager.cpp
+++ b/src/libprojectM/Renderer/TransitionShaderManager.cpp
@@ -4,6 +4,9 @@
 
 #include <iostream>
 
+namespace libprojectM {
+namespace Renderer {
+
 TransitionShaderManager::TransitionShaderManager()
     : m_transitionShaders({CompileTransitionShader(kTransitionShaderBuiltInCircleGlsl330),
                            CompileTransitionShader(kTransitionShaderBuiltInPlasmaGlsl330),
@@ -52,3 +55,6 @@ auto TransitionShaderManager::CompileTransitionShader(const std::string& shaderB
         return {};
     }
 }
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/TransitionShaderManager.hpp b/src/libprojectM/Renderer/TransitionShaderManager.hpp
index 53e056676..a32ffd50a 100644
--- a/src/libprojectM/Renderer/TransitionShaderManager.hpp
+++ b/src/libprojectM/Renderer/TransitionShaderManager.hpp
@@ -4,6 +4,9 @@
 
 #include <random>
 
+namespace libprojectM {
+namespace Renderer {
+
 /**
  * @brief Manages all available transition shaders.
  */
@@ -30,3 +33,6 @@ private:
     std::random_device m_randomDevice; //!< Seed for the random number generator
     std::mt19937 m_mersenneTwister; //!< Random engine to select shader
 };
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/StaticLibDummy.cpp b/src/libprojectM/StaticLibDummy.cpp
index fa4d98fd6..c62e5ae20 100644
--- a/src/libprojectM/StaticLibDummy.cpp
+++ b/src/libprojectM/StaticLibDummy.cpp
@@ -3,4 +3,8 @@
  * Linking this file will not add any code to the executables as the function is never referenced.
  */
 
+namespace libprojectM {
+
 void DummyFunction() {}
+
+} // namespace libprojectM
diff --git a/src/libprojectM/TimeKeeper.cpp b/src/libprojectM/TimeKeeper.cpp
index 91c35a0ed..ecb7e76f7 100644
--- a/src/libprojectM/TimeKeeper.cpp
+++ b/src/libprojectM/TimeKeeper.cpp
@@ -4,6 +4,8 @@
 
 #include <algorithm>
 
+namespace libprojectM {
+
 TimeKeeper::TimeKeeper(double presetDuration, double smoothDuration, double hardcutDuration, double easterEgg)
     : m_easterEgg(easterEgg)
     , m_presetDuration(presetDuration)
@@ -108,3 +110,5 @@ double TimeKeeper::sampledPresetDuration()
     return std::max<double>(1, RandomNumberGenerators::gaussian(m_presetDuration, m_easterEgg));
 
 }
+
+} // namespace libprojectM
diff --git a/src/libprojectM/TimeKeeper.hpp b/src/libprojectM/TimeKeeper.hpp
index 273f1c6ec..accf64353 100644
--- a/src/libprojectM/TimeKeeper.hpp
+++ b/src/libprojectM/TimeKeeper.hpp
@@ -2,6 +2,8 @@
 
 #include <chrono>
 
+namespace libprojectM {
+
 class TimeKeeper
 {
 
@@ -106,3 +108,5 @@ private:
 
     bool m_isSmoothing{false};
 };
+
+} // namespace libprojectM
diff --git a/src/playlist/Filter.cpp b/src/playlist/Filter.cpp
index ce56de5ac..90035aca6 100644
--- a/src/playlist/Filter.cpp
+++ b/src/playlist/Filter.cpp
@@ -2,7 +2,7 @@
 
 #include <cstring>
 
-namespace ProjectM {
+namespace libprojectM {
 namespace Playlist {
 
 auto Filter::List() const -> const std::vector<std::string>&
@@ -156,4 +156,4 @@ auto Filter::ApplyExpression(const std::string& filename, const std::string& fil
 
 
 } // namespace Playlist
-} // namespace ProjectM
+} // namespace libprojectM
diff --git a/src/playlist/Filter.hpp b/src/playlist/Filter.hpp
index a84550266..289f0d43f 100644
--- a/src/playlist/Filter.hpp
+++ b/src/playlist/Filter.hpp
@@ -3,7 +3,7 @@
 #include <string>
 #include <vector>
 
-namespace ProjectM {
+namespace libprojectM {
 namespace Playlist {
 
 /**
@@ -50,4 +50,4 @@ private:
 };
 
 } // namespace Playlist
-} // namespace ProjectM
+} // namespace libprojectM
diff --git a/src/playlist/Item.cpp b/src/playlist/Item.cpp
index 2bb7d6da6..2f88a7bd9 100644
--- a/src/playlist/Item.cpp
+++ b/src/playlist/Item.cpp
@@ -1,6 +1,6 @@
 #include "Item.hpp"
 
-namespace ProjectM {
+namespace libprojectM {
 namespace Playlist {
 
 Item::Item(std::string filename)
@@ -21,4 +21,4 @@ auto Item::operator==(const std::string& other) const -> bool
 }
 
 } // namespace Playlist
-} // namespace ProjectM
+} // namespace libprojectM
diff --git a/src/playlist/Item.hpp b/src/playlist/Item.hpp
index 04040e441..8cff547d6 100644
--- a/src/playlist/Item.hpp
+++ b/src/playlist/Item.hpp
@@ -2,7 +2,7 @@
 
 #include <string>
 
-namespace ProjectM {
+namespace libprojectM {
 namespace Playlist {
 
 class Item
@@ -30,4 +30,4 @@ private:
 };
 
 } // namespace Playlist
-} // namespace ProjectM
+} // namespace libprojectM
diff --git a/src/playlist/Playlist.cpp b/src/playlist/Playlist.cpp
index 33e8db21c..d7c360bc6 100644
--- a/src/playlist/Playlist.cpp
+++ b/src/playlist/Playlist.cpp
@@ -6,7 +6,7 @@
 #include FS_INCLUDE
 using namespace FS_NAMESPACE::filesystem;
 
-namespace ProjectM {
+namespace libprojectM {
 namespace Playlist {
 
 const char* PlaylistEmptyException::what() const noexcept
@@ -382,4 +382,4 @@ void Playlist::AddCurrentPresetIndexToHistory()
 
 
 } // namespace Playlist
-} // namespace ProjectM
+} // namespace libprojectM
diff --git a/src/playlist/Playlist.hpp b/src/playlist/Playlist.hpp
index 38fb9bc72..e7e75e3f8 100644
--- a/src/playlist/Playlist.hpp
+++ b/src/playlist/Playlist.hpp
@@ -10,7 +10,7 @@
 #include <string>
 #include <vector>
 
-namespace ProjectM {
+namespace libprojectM {
 namespace Playlist {
 
 /**
@@ -257,4 +257,4 @@ private:
 };
 
 } // namespace Playlist
-} // namespace ProjectM
+} // namespace libprojectM
diff --git a/src/playlist/PlaylistCWrapper.cpp b/src/playlist/PlaylistCWrapper.cpp
index f00b69b2e..8f83b56dd 100644
--- a/src/playlist/PlaylistCWrapper.cpp
+++ b/src/playlist/PlaylistCWrapper.cpp
@@ -3,7 +3,8 @@
 #include "projectM-4/callbacks.h"
 #include "projectM-4/core.h"
 
-using ProjectM::Playlist::Playlist;
+namespace libprojectM {
+namespace Playlist {
 
 PlaylistCWrapper::PlaylistCWrapper(projectm_handle projectMInstance)
     : m_projectMInstance(projectMInstance)
@@ -47,7 +48,7 @@ void PlaylistCWrapper::OnPresetSwitchRequested(bool isHardCut, void* userData)
     {
         playlist->PlayPresetIndex(playlist->NextPresetIndex(), isHardCut, true);
     }
-    catch (ProjectM::Playlist::PlaylistEmptyException&)
+    catch (PlaylistEmptyException&)
     {
     }
 }
@@ -135,10 +136,12 @@ void PlaylistCWrapper::PlayPresetIndex(size_t index, bool hardCut, bool resetFai
     }
 }
 
+} // namespace Playlist
+} // namespace libprojectM
 
-auto playlist_handle_to_instance(projectm_playlist_handle instance) -> PlaylistCWrapper*
+auto playlist_handle_to_instance(projectm_playlist_handle instance) -> libprojectM::Playlist::PlaylistCWrapper*
 {
-    return reinterpret_cast<PlaylistCWrapper*>(instance);
+    return reinterpret_cast<libprojectM::Playlist::PlaylistCWrapper*>(instance);
 }
 
 
@@ -164,7 +167,7 @@ auto projectm_playlist_create(projectm_handle projectm_instance) -> projectm_pla
 {
     try
     {
-        auto* instance = new PlaylistCWrapper(projectm_instance);
+        auto* instance = new libprojectM::Playlist::PlaylistCWrapper(projectm_instance);
         return reinterpret_cast<projectm_playlist*>(instance);
     }
     catch (...)
@@ -269,7 +272,7 @@ auto projectm_playlist_add_path(projectm_playlist_handle instance, const char* p
 {
     auto* playlist = playlist_handle_to_instance(instance);
 
-    return playlist->AddPath(path, Playlist::InsertAtEnd, recurse_subdirs, allow_duplicates);
+    return playlist->AddPath(path, libprojectM::Playlist::Playlist::InsertAtEnd, recurse_subdirs, allow_duplicates);
 }
 
 
@@ -287,7 +290,7 @@ auto projectm_playlist_add_preset(projectm_playlist_handle instance, const char*
 {
     auto* playlist = playlist_handle_to_instance(instance);
 
-    return playlist->AddItem(filename, Playlist::InsertAtEnd, allow_duplicates);
+    return playlist->AddItem(filename, libprojectM::Playlist::Playlist::InsertAtEnd, allow_duplicates);
 }
 
 
@@ -319,7 +322,7 @@ uint32_t projectm_playlist_add_presets(projectm_playlist_handle instance, const
             continue;
         }
 
-        if (playlist->AddItem(filenames[index], Playlist::InsertAtEnd, allow_duplicates))
+        if (playlist->AddItem(filenames[index], libprojectM::Playlist::Playlist::InsertAtEnd, allow_duplicates))
         {
             addCount++;
         }
@@ -407,17 +410,17 @@ void projectm_playlist_sort(projectm_playlist_handle instance, uint32_t start_in
 {
     auto* playlist = playlist_handle_to_instance(instance);
 
-    Playlist::SortPredicate predicatePlaylist{ProjectM::Playlist::Playlist::SortPredicate::FullPath};
-    Playlist::SortOrder orderPlaylist{ProjectM::Playlist::Playlist::SortOrder::Ascending};
+    libprojectM::Playlist::Playlist::SortPredicate predicatePlaylist{libprojectM::Playlist::Playlist::SortPredicate::FullPath};
+    libprojectM::Playlist::Playlist::SortOrder orderPlaylist{libprojectM::Playlist::Playlist::SortOrder::Ascending};
 
     if (predicate == SORT_PREDICATE_FILENAME_ONLY)
     {
-        predicatePlaylist = ProjectM::Playlist::Playlist::SortPredicate::FilenameOnly;
+        predicatePlaylist = libprojectM::Playlist::Playlist::SortPredicate::FilenameOnly;
     }
 
     if (order == SORT_ORDER_DESCENDING)
     {
-        orderPlaylist = ProjectM::Playlist::Playlist::SortOrder::Descending;
+        orderPlaylist = libprojectM::Playlist::Playlist::SortOrder::Descending;
     }
 
     playlist->Sort(start_index, count, predicatePlaylist, orderPlaylist);
@@ -445,7 +448,7 @@ auto projectm_playlist_get_position(projectm_playlist_handle instance) -> uint32
     {
         return playlist->PresetIndex();
     }
-    catch (ProjectM::Playlist::PlaylistEmptyException&)
+    catch (libprojectM::Playlist::PlaylistEmptyException&)
     {
         return 0;
     }
@@ -462,7 +465,7 @@ auto projectm_playlist_set_position(projectm_playlist_handle instance, uint32_t
         playlist->PlayPresetIndex(newIndex, hard_cut, true);
         return playlist->PresetIndex();
     }
-    catch (ProjectM::Playlist::PlaylistEmptyException&)
+    catch (libprojectM::Playlist::PlaylistEmptyException&)
     {
         return 0;
     }
@@ -478,7 +481,7 @@ uint32_t projectm_playlist_play_next(projectm_playlist_handle instance, bool har
         playlist->PlayPresetIndex(newIndex, hard_cut, true);
         return playlist->PresetIndex();
     }
-    catch (ProjectM::Playlist::PlaylistEmptyException&)
+    catch (libprojectM::Playlist::PlaylistEmptyException&)
     {
         return 0;
     }
@@ -494,7 +497,7 @@ uint32_t projectm_playlist_play_previous(projectm_playlist_handle instance, bool
         playlist->PlayPresetIndex(newIndex, hard_cut, true);
         return playlist->PresetIndex();
     }
-    catch (ProjectM::Playlist::PlaylistEmptyException&)
+    catch (libprojectM::Playlist::PlaylistEmptyException&)
     {
         return 0;
     }
@@ -510,7 +513,7 @@ uint32_t projectm_playlist_play_last(projectm_playlist_handle instance, bool har
         playlist->PlayPresetIndex(newIndex, hard_cut, true);
         return playlist->PresetIndex();
     }
-    catch (ProjectM::Playlist::PlaylistEmptyException&)
+    catch (libprojectM::Playlist::PlaylistEmptyException&)
     {
         return 0;
     }
diff --git a/src/playlist/PlaylistCWrapper.hpp b/src/playlist/PlaylistCWrapper.hpp
index 09ad9a16f..115318807 100644
--- a/src/playlist/PlaylistCWrapper.hpp
+++ b/src/playlist/PlaylistCWrapper.hpp
@@ -7,7 +7,10 @@
 #include <string>
 #include <vector>
 
-class PlaylistCWrapper : public ProjectM::Playlist::Playlist
+namespace libprojectM {
+namespace Playlist {
+
+class PlaylistCWrapper : public Playlist
 {
 public:
     PlaylistCWrapper() = delete;
@@ -84,3 +87,6 @@ private:
     projectm_playlist_preset_switch_failed_event m_presetSwitchFailedEventCallback{nullptr}; //!< Preset switch failed callback pointer set by the application.
     void* m_presetSwitchFailedEventUserData{nullptr};                                        //!< Context data pointer set by the application.
 };
+
+} // namespace Playlist
+} // namespace libprojectM
diff --git a/tests/libprojectM/PresetFileParserTest.cpp b/tests/libprojectM/PresetFileParserTest.cpp
index 15d7e76d5..ffe59afdd 100644
--- a/tests/libprojectM/PresetFileParserTest.cpp
+++ b/tests/libprojectM/PresetFileParserTest.cpp
@@ -4,6 +4,8 @@
 
 static constexpr auto fileParserTestDataPath{ PROJECTM_TEST_DATA_DIR "/PresetFileParser/" };
 
+using libprojectM::MilkdropPreset::PresetFileParser;
+
 /**
  * Class to make protected function accessible to tests.
  */
diff --git a/tests/playlist/APITest.cpp b/tests/playlist/APITest.cpp
index 7f186cbac..b74cb267a 100644
--- a/tests/playlist/APITest.cpp
+++ b/tests/playlist/APITest.cpp
@@ -69,9 +69,9 @@ TEST(projectMPlaylistAPI, ItemsAll)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    std::vector<ProjectM::Playlist::Item> items{
-        ProjectM::Playlist::Item("/some/file"),
-        ProjectM::Playlist::Item("/another/file")};
+    std::vector<libprojectM::Playlist::Item> items{
+        libprojectM::Playlist::Item("/some/file"),
+        libprojectM::Playlist::Item("/another/file")};
 
     EXPECT_CALL(mockPlaylist, Items())
         .Times(1)
@@ -94,13 +94,13 @@ TEST(projectMPlaylistAPI, ItemsPartial)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    std::vector<ProjectM::Playlist::Item> items{
-        ProjectM::Playlist::Item("/some/file"),
-        ProjectM::Playlist::Item("/another/file1"),
-        ProjectM::Playlist::Item("/another/file2"),
-        ProjectM::Playlist::Item("/another/file3"),
-        ProjectM::Playlist::Item("/another/file4"),
-        ProjectM::Playlist::Item("/another/file5")};
+    std::vector<libprojectM::Playlist::Item> items{
+        libprojectM::Playlist::Item("/some/file"),
+        libprojectM::Playlist::Item("/another/file1"),
+        libprojectM::Playlist::Item("/another/file2"),
+        libprojectM::Playlist::Item("/another/file3"),
+        libprojectM::Playlist::Item("/another/file4"),
+        libprojectM::Playlist::Item("/another/file5")};
 
     EXPECT_CALL(mockPlaylist, Items())
         .Times(1)
@@ -124,13 +124,13 @@ TEST(projectMPlaylistAPI, ItemsOutOfRange)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    std::vector<ProjectM::Playlist::Item> items{
-        ProjectM::Playlist::Item("/some/file"),
-        ProjectM::Playlist::Item("/another/file1"),
-        ProjectM::Playlist::Item("/another/file2"),
-        ProjectM::Playlist::Item("/another/file3"),
-        ProjectM::Playlist::Item("/another/file4"),
-        ProjectM::Playlist::Item("/another/file5")};
+    std::vector<libprojectM::Playlist::Item> items{
+        libprojectM::Playlist::Item("/some/file"),
+        libprojectM::Playlist::Item("/another/file1"),
+        libprojectM::Playlist::Item("/another/file2"),
+        libprojectM::Playlist::Item("/another/file3"),
+        libprojectM::Playlist::Item("/another/file4"),
+        libprojectM::Playlist::Item("/another/file5")};
 
     EXPECT_CALL(mockPlaylist, Items())
         .Times(1)
@@ -148,9 +148,9 @@ TEST(projectMPlaylistAPI, Item)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    std::vector<ProjectM::Playlist::Item> items{
-        ProjectM::Playlist::Item("/some/file"),
-        ProjectM::Playlist::Item("/another/file")};
+    std::vector<libprojectM::Playlist::Item> items{
+        libprojectM::Playlist::Item("/some/file"),
+        libprojectM::Playlist::Item("/another/file")};
 
     EXPECT_CALL(mockPlaylist, Empty())
         .Times(1)
@@ -174,9 +174,9 @@ TEST(projectMPlaylistAPI, ItemEmptyPlaylist)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    std::vector<ProjectM::Playlist::Item> items{
-        ProjectM::Playlist::Item("/some/file"),
-        ProjectM::Playlist::Item("/another/file")};
+    std::vector<libprojectM::Playlist::Item> items{
+        libprojectM::Playlist::Item("/some/file"),
+        libprojectM::Playlist::Item("/another/file")};
 
     EXPECT_CALL(mockPlaylist, Empty())
         .Times(1)
@@ -190,9 +190,9 @@ TEST(projectMPlaylistAPI, ItemIndexOutOfBounds)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    std::vector<ProjectM::Playlist::Item> items{
-        ProjectM::Playlist::Item("/some/file"),
-        ProjectM::Playlist::Item("/another/file")};
+    std::vector<libprojectM::Playlist::Item> items{
+        libprojectM::Playlist::Item("/some/file"),
+        libprojectM::Playlist::Item("/another/file")};
 
     EXPECT_CALL(mockPlaylist, Empty())
         .Times(1)
@@ -209,7 +209,7 @@ TEST(projectMPlaylistAPI, AddPath)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    EXPECT_CALL(mockPlaylist, AddPath("/some/path", ProjectM::Playlist::Playlist::InsertAtEnd, true, false))
+    EXPECT_CALL(mockPlaylist, AddPath("/some/path", libprojectM::Playlist::Playlist::InsertAtEnd, true, false))
         .Times(1)
         .WillOnce(Return(35));
 
@@ -233,7 +233,7 @@ TEST(projectMPlaylistAPI, AddPreset)
 {
     PlaylistCWrapperMock mockPlaylist;
 
-    EXPECT_CALL(mockPlaylist, AddItem("/some/file", ProjectM::Playlist::Playlist::InsertAtEnd, false))
+    EXPECT_CALL(mockPlaylist, AddItem("/some/file", libprojectM::Playlist::Playlist::InsertAtEnd, false))
         .Times(1)
         .WillOnce(Return(true));
 
@@ -262,10 +262,10 @@ TEST(projectMPlaylistAPI, AddPresets)
     const char thirdFile[]{"/another/file"};
     const char* presetList[]{firstFile, secondFile, thirdFile};
 
-    EXPECT_CALL(mockPlaylist, AddItem("/some/file", ProjectM::Playlist::Playlist::InsertAtEnd, false))
+    EXPECT_CALL(mockPlaylist, AddItem("/some/file", libprojectM::Playlist::Playlist::InsertAtEnd, false))
         .Times(1)
         .WillOnce(Return(true));
-    EXPECT_CALL(mockPlaylist, AddItem("/another/file", ProjectM::Playlist::Playlist::InsertAtEnd, false))
+    EXPECT_CALL(mockPlaylist, AddItem("/another/file", libprojectM::Playlist::Playlist::InsertAtEnd, false))
         .Times(2)
         .WillOnce(Return(true))
         .WillOnce(Return(false));
@@ -353,7 +353,7 @@ TEST(projectMPlaylistAPI, SetShuffle)
 
 TEST(projectMPlaylistAPI, Sort)
 {
-    using ProjectM::Playlist::Playlist;
+    using libprojectM::Playlist::Playlist;
 
     PlaylistCWrapperMock mockPlaylist;
 
@@ -422,7 +422,7 @@ TEST(projectMPlaylistAPI, GetPositionException)
 
     EXPECT_CALL(mockPlaylist, PresetIndex())
         .Times(1)
-        .WillOnce(Throw(ProjectM::Playlist::PlaylistEmptyException()));
+        .WillOnce(Throw(libprojectM::Playlist::PlaylistEmptyException()));
 
     EXPECT_EQ(projectm_playlist_get_position(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist)), 0);
 }
@@ -454,7 +454,7 @@ TEST(projectMPlaylistAPI, SetPositionException)
 
     EXPECT_CALL(mockPlaylist, SetPresetIndex(256))
         .Times(2)
-        .WillRepeatedly(Throw(ProjectM::Playlist::PlaylistEmptyException()));
+        .WillRepeatedly(Throw(libprojectM::Playlist::PlaylistEmptyException()));
 
     EXPECT_EQ(projectm_playlist_set_position(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), 256, true), 0);
     EXPECT_EQ(projectm_playlist_set_position(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), 256, false), 0);
@@ -487,7 +487,7 @@ TEST(projectMPlaylistAPI, PlayNextException)
 
     EXPECT_CALL(mockPlaylist, NextPresetIndex())
         .Times(2)
-        .WillRepeatedly(Throw(ProjectM::Playlist::PlaylistEmptyException()));
+        .WillRepeatedly(Throw(libprojectM::Playlist::PlaylistEmptyException()));
 
     EXPECT_EQ(projectm_playlist_play_next(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), true), 0);
     EXPECT_EQ(projectm_playlist_play_next(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), false), 0);
@@ -520,7 +520,7 @@ TEST(projectMPlaylistAPI, PlayPreviousException)
 
     EXPECT_CALL(mockPlaylist, PreviousPresetIndex())
         .Times(2)
-        .WillRepeatedly(Throw(ProjectM::Playlist::PlaylistEmptyException()));
+        .WillRepeatedly(Throw(libprojectM::Playlist::PlaylistEmptyException()));
 
     EXPECT_EQ(projectm_playlist_play_previous(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), true), 0);
     EXPECT_EQ(projectm_playlist_play_previous(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), false), 0);
@@ -553,7 +553,7 @@ TEST(projectMPlaylistAPI, PlayLastException)
 
     EXPECT_CALL(mockPlaylist, LastPresetIndex())
         .Times(2)
-        .WillRepeatedly(Throw(ProjectM::Playlist::PlaylistEmptyException()));
+        .WillRepeatedly(Throw(libprojectM::Playlist::PlaylistEmptyException()));
 
     EXPECT_EQ(projectm_playlist_play_last(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), true), 0);
     EXPECT_EQ(projectm_playlist_play_last(reinterpret_cast<projectm_playlist_handle>(&mockPlaylist), false), 0);
@@ -595,7 +595,7 @@ TEST(projectMPlaylistAPI, SetPresetSwitchFailedCallback)
 TEST(projectMPlaylistAPI, SetFilter)
 {
     PlaylistCWrapperMock mockPlaylist;
-    ProjectM::Playlist::Filter filter;
+    libprojectM::Playlist::Filter filter;
 
     EXPECT_CALL(mockPlaylist, Filter())
         .Times(1)
@@ -619,7 +619,7 @@ TEST(projectMPlaylistAPI, SetFilter)
 TEST(projectMPlaylistAPI, GetFilter)
 {
     PlaylistCWrapperMock mockPlaylist;
-    ProjectM::Playlist::Filter filter;
+    libprojectM::Playlist::Filter filter;
 
     filter.SetList({"-/some/BadPreset.milk",
                     "+/another/AwesomePreset.milk",
diff --git a/tests/playlist/FilterTest.cpp b/tests/playlist/FilterTest.cpp
index 12c64862e..2686c5f85 100644
--- a/tests/playlist/FilterTest.cpp
+++ b/tests/playlist/FilterTest.cpp
@@ -2,9 +2,11 @@
 
 #include <gtest/gtest.h>
 
+using libprojectM::Playlist::Filter;
+
 TEST(projectMPlaylistFilter, List)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-TestString.milk",
                     "+AnotherTestString*"});
@@ -19,7 +21,7 @@ TEST(projectMPlaylistFilter, List)
 
 TEST(projectMPlaylistFilter, ExactMatchExclude)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-TestString.milk"});
 
@@ -30,7 +32,7 @@ TEST(projectMPlaylistFilter, ExactMatchExclude)
 
 TEST(projectMPlaylistFilter, ExactMatchExcludePath)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-/path/to/TestString.milk"});
 
@@ -41,7 +43,7 @@ TEST(projectMPlaylistFilter, ExactMatchExcludePath)
 
 TEST(projectMPlaylistFilter, SingleCharacterExclude)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-/path/to/TestStr?ng.milk"});
 
@@ -54,7 +56,7 @@ TEST(projectMPlaylistFilter, SingleCharacterExclude)
 
 TEST(projectMPlaylistFilter, MultiCharacterExclude)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-/path/to/Test*.milk"});
 
@@ -68,7 +70,7 @@ TEST(projectMPlaylistFilter, MultiCharacterExclude)
 
 TEST(projectMPlaylistFilter, MultiCharacterExcludeExamples)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-a"});
     EXPECT_FALSE(filter.Passes("a"));
@@ -96,7 +98,7 @@ TEST(projectMPlaylistFilter, MultiCharacterExcludeExamples)
 
 TEST(projectMPlaylistFilter, PathGlobExclude)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-**/Test.milk"});
 
@@ -110,7 +112,7 @@ TEST(projectMPlaylistFilter, PathGlobExclude)
 
 TEST(projectMPlaylistFilter, PathGlobExcludeExamples)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-**/a"});
     EXPECT_FALSE(filter.Passes("a"));
@@ -137,7 +139,7 @@ TEST(projectMPlaylistFilter, PathGlobExcludeExamples)
 
 TEST(projectMPlaylistFilter, LargeGlobs)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a*a"});
     EXPECT_FALSE(filter.Passes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
@@ -151,7 +153,7 @@ TEST(projectMPlaylistFilter, LargeGlobs)
 
 TEST(projectMPlaylistFilter, MultipleFilters)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-/path/to/Test*.milk",
                     "/path/to/another\\Test*.milk",
@@ -168,7 +170,7 @@ TEST(projectMPlaylistFilter, MultipleFilters)
 
 TEST(projectMPlaylistFilter, MatchEverything)
 {
-    ProjectM::Playlist::Filter filter;
+    Filter filter;
 
     filter.SetList({"-/**"});
 
diff --git a/tests/playlist/ItemTest.cpp b/tests/playlist/ItemTest.cpp
index 20fac16f9..834b08a3a 100644
--- a/tests/playlist/ItemTest.cpp
+++ b/tests/playlist/ItemTest.cpp
@@ -4,13 +4,13 @@
 
 TEST(projectMPlaylistItem, Create)
 {
-    ASSERT_NO_THROW(ProjectM::Playlist::Item item("/some/file"));
+    ASSERT_NO_THROW(libprojectM::Playlist::Item item("/some/file"));
 }
 
 
 TEST(projectMPlaylistItem, GetFilename)
 {
-    ProjectM::Playlist::Item item("/some/file");
+    libprojectM::Playlist::Item item("/some/file");
 
     ASSERT_EQ(item.Filename(), "/some/file");
 }
@@ -18,7 +18,7 @@ TEST(projectMPlaylistItem, GetFilename)
 
 TEST(projectMPlaylistItem, FilenameEquality)
 {
-    ProjectM::Playlist::Item item("/some/file");
+    libprojectM::Playlist::Item item("/some/file");
 
     EXPECT_TRUE(item == "/some/file");
     EXPECT_FALSE(item == "/some/other/file");
diff --git a/tests/playlist/PlaylistCWrapperMock.h b/tests/playlist/PlaylistCWrapperMock.h
index 65e85101e..b0ddb3c82 100644
--- a/tests/playlist/PlaylistCWrapperMock.h
+++ b/tests/playlist/PlaylistCWrapperMock.h
@@ -4,7 +4,7 @@
 
 #include <gmock/gmock.h>
 
-class PlaylistCWrapperMock : public PlaylistCWrapper
+class PlaylistCWrapperMock : public libprojectM::Playlist::PlaylistCWrapper
 {
 public:
     PlaylistCWrapperMock()
@@ -17,7 +17,7 @@ public:
     MOCK_METHOD(uint32_t, Size, (), (const));
     MOCK_METHOD(bool, Empty, (), (const));
     MOCK_METHOD(void, Clear, ());
-    MOCK_METHOD(const std::vector<ProjectM::Playlist::Item>&, Items, (), (const));
+    MOCK_METHOD(const std::vector<libprojectM::Playlist::Item>&, Items, (), (const));
     MOCK_METHOD(bool, AddItem, (const std::string&, uint32_t, bool) );
     MOCK_METHOD(uint32_t, AddPath, (const std::string&, uint32_t, bool, bool) );
     MOCK_METHOD(bool, RemoveItem, (uint32_t));
@@ -35,6 +35,6 @@ public:
     MOCK_METHOD(void, RemoveLastHistoryEntry, ());
     MOCK_METHOD(void, SetPresetSwitchedCallback, (projectm_playlist_preset_switched_event, void*) );
     MOCK_METHOD(void, SetPresetSwitchFailedCallback, (projectm_playlist_preset_switch_failed_event, void*) );
-    MOCK_METHOD(class ProjectM::Playlist::Filter&, Filter, ());
+    MOCK_METHOD(class libprojectM::Playlist::Filter&, Filter, ());
     MOCK_METHOD(size_t, ApplyFilter, ());
 };
diff --git a/tests/playlist/PlaylistTest.cpp b/tests/playlist/PlaylistTest.cpp
index 3052131be..7ae4ff335 100644
--- a/tests/playlist/PlaylistTest.cpp
+++ b/tests/playlist/PlaylistTest.cpp
@@ -4,7 +4,8 @@
 
 #include <algorithm>
 
-using ProjectM::Playlist::Playlist;
+using libprojectM::Playlist::Item;
+using libprojectM::Playlist::Playlist;
 
 TEST(projectMPlaylistPlaylist, Create)
 {
@@ -162,13 +163,13 @@ TEST(projectMPlaylistPlaylist, AddPathRecursively)
     const auto& items = playlist.Items();
     ASSERT_EQ(items.size(), 4);
 
-    EXPECT_NE(std::find_if(items.cbegin(), items.cend(), [](const ProjectM::Playlist::Item& item) {
+    EXPECT_NE(std::find_if(items.cbegin(), items.cend(), [](const Item& item) {
                   return item.Filename().substr(item.Filename().length() - 11, 11) == "Test_D.milk";
               }),
               items.cend())
         << "Expected file not found in playlist.";
 
-    EXPECT_EQ(std::find_if(items.cbegin(), items.cend(), [](const ProjectM::Playlist::Item& item) {
+    EXPECT_EQ(std::find_if(items.cbegin(), items.cend(), [](const Item& item) {
                   return item.Filename().substr(item.Filename().length() - 10, 10) == "Other.file";
               }),
               items.cend())
@@ -197,19 +198,19 @@ TEST(projectMPlaylistPlaylist, AddPathNonRecursively)
     const auto& items = playlist.Items();
     ASSERT_EQ(items.size(), 3);
 
-    EXPECT_NE(std::find_if(items.cbegin(), items.cend(), [](const ProjectM::Playlist::Item& item) {
+    EXPECT_NE(std::find_if(items.cbegin(), items.cend(), [](const Item& item) {
                   return item.Filename().substr(item.Filename().length() - 11, 11) == "Test_B.milk";
               }),
               items.cend())
         << "Expected file not found in playlist.";
 
-    EXPECT_EQ(std::find_if(items.cbegin(), items.cend(), [](const ProjectM::Playlist::Item& item) {
+    EXPECT_EQ(std::find_if(items.cbegin(), items.cend(), [](const Item& item) {
                   return item.Filename().substr(item.Filename().length() - 11, 11) == "Test_D.milk";
               }),
               items.cend())
         << "Unexpected file found in playlist.";
 
-    EXPECT_EQ(std::find_if(items.cbegin(), items.cend(), [](const ProjectM::Playlist::Item& item) {
+    EXPECT_EQ(std::find_if(items.cbegin(), items.cend(), [](const Item& item) {
                   return item.Filename().substr(item.Filename().length() - 10, 10) == "Other.file";
               }),
               items.cend())
@@ -461,7 +462,7 @@ TEST(projectMPlaylistPlaylist, NextPresetIndexEmptyPlaylist)
 {
     Playlist playlist;
 
-    EXPECT_THROW(playlist.NextPresetIndex(), ProjectM::Playlist::PlaylistEmptyException);
+    EXPECT_THROW(playlist.NextPresetIndex(), libprojectM::Playlist::PlaylistEmptyException);
 }
 
 
@@ -509,7 +510,7 @@ TEST(projectMPlaylistPlaylist, PreviousPresetIndexEmptyPlaylist)
 {
     Playlist playlist;
 
-    EXPECT_THROW(playlist.PreviousPresetIndex(), ProjectM::Playlist::PlaylistEmptyException);
+    EXPECT_THROW(playlist.PreviousPresetIndex(), libprojectM::Playlist::PlaylistEmptyException);
 }
 
 
@@ -596,7 +597,7 @@ TEST(projectMPlaylistPlaylist, LastPresetIndexEmptyPlaylist)
 {
     Playlist playlist;
 
-    EXPECT_THROW(playlist.LastPresetIndex(), ProjectM::Playlist::PlaylistEmptyException);
+    EXPECT_THROW(playlist.LastPresetIndex(), libprojectM::Playlist::PlaylistEmptyException);
 }
 
 
@@ -630,7 +631,7 @@ TEST(projectMPlaylistPlaylist, SetPresetIndexException)
 {
     Playlist playlist;
 
-    EXPECT_THROW(playlist.SetPresetIndex(0), ProjectM::Playlist::PlaylistEmptyException);
+    EXPECT_THROW(playlist.SetPresetIndex(0), libprojectM::Playlist::PlaylistEmptyException);
 }
 
 
@@ -652,7 +653,7 @@ TEST(projectMPlaylistPlaylist, PresetIndexException)
 {
     Playlist playlist;
 
-    EXPECT_THROW(playlist.PresetIndex(), ProjectM::Playlist::PlaylistEmptyException);
+    EXPECT_THROW(playlist.PresetIndex(), libprojectM::Playlist::PlaylistEmptyException);
 }