chore: fix inconsistencies

src/WallpaperEngine/Data/Model/DynamicValue.h

@@ -33,7 +33,7 @@ class DynamicValue {
     explicit DynamicValue(float value);
     explicit DynamicValue(int value);
     explicit DynamicValue(bool value);
-    ~DynamicValue ();
+    virtual ~DynamicValue ();
 
     [[nodiscard]] const glm::ivec4& getIVec4 () const;
     [[nodiscard]] const glm::ivec3& getIVec3 () const;

src/WallpaperEngine/Data/Model/Effect.h

@@ -29,6 +29,7 @@ struct EffectPass {
     /** The target this material renders to (if specified) */
     std::optional <std::string> target;
 };
+
 struct Effect {
     /** Effect's name for the UI */
     std::string name;

src/WallpaperEngine/Data/Model/Material.h

@@ -8,16 +8,42 @@
 #include "Types.h"
 
 namespace WallpaperEngine::Data::Model {
+
+enum BlendingMode {
+    BlendingMode_Unknown = 0,
+    BlendingMode_Normal = 1,
+    BlendingMode_Translucent = 2,
+    BlendingMode_Additive = 3,
+};
+
+enum CullingMode {
+    CullingMode_Unknown = 0,
+    CullingMode_Normal = 1,
+    CullingMode_Disable = 2
+};
+
+enum DepthtestMode {
+    DepthtestMode_Unknown = 0,
+    DepthtestMode_Disabled = 1,
+    DepthtestMode_Enabled = 2,
+};
+
+enum DepthwriteMode {
+    DepthwriteMode_Unknown = 0,
+    DepthwriteMode_Disabled = 1,
+    DepthwriteMode_Enabled = 2,
+};
+
 struct MaterialPass {
     // TODO: WRITE ENUMS FOR THESE
     /** Blending mode */
-    std::string blending;
+    BlendingMode blending;
     /** Culling mode */
-    std::string cullmode;
+    CullingMode cullmode;
     /** Depth test mode */
-    std::string depthtest;
+    DepthtestMode depthtest;
     /** Depth write mode */
-    std::string depthwrite;
+    DepthwriteMode depthwrite;
     /** Shader file to use for this pass */
     std::string shader;
     /** List of textures defined for this pass */

src/WallpaperEngine/Data/Model/Object.h

@@ -7,13 +7,14 @@
 #include <glm/glm.hpp>
 
 #include "Types.h"
-#include "Effect.h"
+#include "UserSetting.h"
 #include "Material.h"
 #include "Model.h"
+#include "Effect.h"
 #include "WallpaperEngine/Data/Utils/TypeCaster.h"
 
 namespace WallpaperEngine::Data::Model {
-using TypeCaster = WallpaperEngine::Data::Utils::TypeCaster;
+using namespace WallpaperEngine::Data::Utils;
 
 struct ObjectData {
     int id;
@@ -48,7 +49,7 @@ struct ImageEffectPassOverride {
     int id;
     ComboMap combos;
     ShaderConstantMap constants;
-    std::map <int, std::string> textures;
+    TextureMap textures;
 };
 
 /**

src/WallpaperEngine/Data/Model/Project.h

@@ -10,7 +10,6 @@ namespace WallpaperEngine::Data::Model {
  * Represents a wallpaper engine project
  */
 struct Project {
-  public:
     enum Type {
         Type_Scene = 0,
         Type_Web = 1,

src/WallpaperEngine/Data/Model/Property.h

@@ -60,7 +60,7 @@ class PropertyBoolean : public Property {
 class PropertyColor : public Property {
   public:
     explicit PropertyColor (PropertyData data, std::string value) : Property (std::move(data)) {
-        this->update (value);
+        this->PropertyColor::update (value);
     }
 
     using Property::update;
@@ -113,7 +113,7 @@ class PropertyColor : public Property {
 class PropertyCombo : public Property, ComboData {
   public:
     PropertyCombo (PropertyData data, ComboData comboData, std::string value) : Property (std::move(data)), ComboData (std::move(comboData)) {
-        this->update (value);
+        this->PropertyCombo::update (value);
     }
 
     using Property::update;
@@ -139,7 +139,7 @@ class PropertyText : public Property {
 class PropertySceneTexture : public Property {
   public:
     explicit PropertySceneTexture (PropertyData data, std::string value) : Property (std::move(data)) {
-        this->update (value);
+        this->PropertySceneTexture::update (value);
     }
 
     void update(const std::string& value) override {

src/WallpaperEngine/Data/Model/Types.h

@@ -14,7 +14,7 @@ class Wallpaper;
 class Scene;
 class Web;
 class Video;
-class UserSetting;
+struct UserSetting;
 class Object;
 class Sound;
 class Image;

src/WallpaperEngine/Data/Model/UserSetting.h

@@ -8,12 +8,11 @@
 
 namespace WallpaperEngine::Data::Model {
 struct ConditionInfo {
-  public:
     std::string name;
     std::string condition;
 };
+
 struct UserSetting {
-  public:
     /**
      * The value of this setting, can be a few different things:
      * - a value connected to the property

src/WallpaperEngine/Data/Model/Wallpaper.h

@@ -8,11 +8,9 @@
 #include "Types.h"
 #include "Object.h"
 #include "WallpaperEngine/Data/Utils/TypeCaster.h"
-#include "WallpaperEngine/Data/JSON.h"
 
 namespace WallpaperEngine::Data::Model {
-using json = WallpaperEngine::Data::JSON::JSON;
-using TypeCaster = WallpaperEngine::Data::Utils::TypeCaster;
+using namespace WallpaperEngine::Data::Utils;
 
 struct WallpaperData {
     std::string filename;
@@ -110,10 +108,8 @@ struct SceneData {
 
 class Scene : public Wallpaper, public SceneData {
   public:
-    explicit Scene (WallpaperData data, SceneData sceneData) noexcept : SceneData (std::move(sceneData)), Wallpaper (data) {}
+    explicit Scene (WallpaperData data, SceneData sceneData) noexcept : Wallpaper (std::move (data)), SceneData (std::move (sceneData)) {}
 
     ~Scene () override = default;
-
-    // TODO: ADD OBJECTS HERE
 };
 } // namespace WallpaperEngine::Data::Model

src/WallpaperEngine/Data/Parsers/MaterialParser.cpp

@@ -41,10 +41,10 @@ MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, Project& projec
 
     return std::make_unique <MaterialPass>(MaterialPass {
         //TODO: REMOVE THIS UGLY STD::STRING CREATION
-        .blending = it.optional ("blending", std::string ("normal")),
-        .cullmode = it.optional ("cullmode", std::string ("disabled")),
-        .depthtest = it.optional ("depthtest", std::string ("disabled")),
-        .depthwrite = it.optional ("depthwrite", std::string ("disabled")),
+        .blending = parseBlendMode (it.optional ("blending", std::string ("normal"))),
+        .cullmode = parseCullMode (it.optional ("cullmode", std::string ("nocull"))),
+        .depthtest = parseDepthtestMode (it.optional ("depthtest", std::string ("disabled"))),
+        .depthwrite = parseDepthwriteMode (it.optional ("depthwrite", std::string ("disabled"))),
         .shader = it.require <std::string> ("shader", "Material pass must have a shader"),
         .textures = textures.has_value () ? parseTextures (*textures) : TextureMap {},
         .usertextures = usertextures.has_value () ? parseTextures (*usertextures) : TextureMap {},
@@ -89,4 +89,60 @@ std::map <std::string, int> MaterialParser::parseCombos (const JSON& it) {
     }
 
     return result;
-}
+}
+
+BlendingMode MaterialParser::parseBlendMode (const std::string& mode) {
+    if (mode == "normal") {
+        return BlendingMode_Normal;
+    }
+
+    if (mode == "additive") {
+        return BlendingMode_Additive;
+    }
+
+    if (mode == "translucent") {
+        return BlendingMode_Translucent;
+    }
+
+    sLog.error ("Unknown blending mode: ", mode, " defaulting to normal");
+    return BlendingMode_Normal;
+}
+
+CullingMode MaterialParser::parseCullMode (const std::string& mode) {
+    if (mode == "nocull") {
+        return CullingMode_Disable;
+    }
+
+    if (mode == "normal") {
+        return CullingMode_Normal;
+    }
+
+    sLog.error ("Unknown culling mode: ", mode, " defaulting to nocull");
+    return CullingMode_Disable;
+}
+
+DepthtestMode MaterialParser::parseDepthtestMode (const std::string& mode) {
+    if (mode == "disabled") {
+        return DepthtestMode_Disabled;
+    }
+
+    if (mode == "enabled") {
+        return DepthtestMode_Enabled;
+    }
+
+    sLog.error ("Unknown depthtest mode: ", mode, " defaulting to disabled");
+    return DepthtestMode_Disabled;
+}
+
+DepthwriteMode MaterialParser::parseDepthwriteMode (const std::string& mode) {
+    if (mode == "disabled") {
+        return DepthwriteMode_Disabled;
+    }
+
+    if (mode == "enabled") {
+        return DepthwriteMode_Enabled;
+    }
+
+    sLog.error ("Unknown depthwrite mode: ", mode, " defaulting to disabled");
+    return DepthwriteMode_Disabled;
+}

src/WallpaperEngine/Data/Parsers/MaterialParser.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Material.h"
 #include "WallpaperEngine/Data/Model/Types.h"
 
 namespace WallpaperEngine::Data::Parsers {
@@ -15,5 +16,9 @@ class MaterialParser {
     static MaterialPassUniquePtr parsePass (const JSON& it, Project& project);
     static std::map <int, std::string> parseTextures (const JSON& it);
     static std::map <std::string, int> parseCombos (const JSON& it);
+    static BlendingMode parseBlendMode (const std::string& mode);
+    static CullingMode parseCullMode (const std::string& mode);
+    static DepthtestMode parseDepthtestMode (const std::string& mode);
+    static DepthwriteMode parseDepthwriteMode (const std::string& mode);
 };
 } // namespace WallpaperEngine::Data::Parsers

src/WallpaperEngine/Render/Objects/CImage.cpp

@@ -294,10 +294,10 @@ void CImage::setup () {
                     }
 
                     const auto virtualPass = MaterialPass {
-                        .blending = "normal",
-                        .cullmode = "nocull",
-                        .depthtest = "disabled",
-                        .depthwrite = "disabled",
+                        .blending = BlendingMode_Normal,
+                        .cullmode = CullingMode_Disable,
+                        .depthtest = DepthtestMode_Disabled,
+                        .depthwrite = DepthwriteMode_Disabled,
                         .shader = "commands/copy",
                         .textures = {
                             {0, *(*curEffect)->source}
@@ -363,7 +363,7 @@ void CImage::setup () {
         const auto last = this->m_passes.rbegin ();
 
         (*last)->setBlendingMode ((*first)->getBlendingMode ());
-        (*first)->setBlendingMode ("normal");
+        (*first)->setBlendingMode (BlendingMode_Normal);
     }
 
     // calculate full animation time (if any)

src/WallpaperEngine/Render/Objects/Effects/CPass.cpp

@@ -89,36 +89,55 @@ void CPass::setupRenderFramebuffer () {
     glViewport (0, 0, this->m_drawTo->getRealWidth (), this->m_drawTo->getRealHeight ());
 
     // set texture blending
-    if (this->getBlendingMode () == "translucent") {
-        glEnable (GL_BLEND);
-        glBlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    } else if (this->getBlendingMode () == "additive") {
-        glEnable (GL_BLEND);
-        glBlendFuncSeparate (GL_SRC_ALPHA, GL_ONE, GL_SRC_ALPHA, GL_ONE);
-    } else if (this->getBlendingMode () == "normal") {
-        glEnable (GL_BLEND);
-        glBlendFuncSeparate (GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
-    } else {
+    switch (this->getBlendingMode ()) {
+        case BlendingMode_Translucent:
+            glEnable (GL_BLEND);
+            glBlendFuncSeparate (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            break;
+        case BlendingMode_Additive:
+            glEnable (GL_BLEND);
+            glBlendFuncSeparate (GL_SRC_ALPHA, GL_ONE, GL_SRC_ALPHA, GL_ONE);
+            break;
+        case BlendingMode_Normal:
+            glEnable (GL_BLEND);
+            glBlendFuncSeparate (GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+            break;
+        default:
         glDisable (GL_BLEND);
+            break;
     }
 
-    // set depth testing
-    if (this->m_pass.depthtest == "disabled") {
-        glDisable (GL_DEPTH_TEST);
-    } else {
-        glEnable (GL_DEPTH_TEST);
+    switch (this->m_pass.depthtest) {
+        case DepthtestMode_Enabled:
+            glEnable (GL_DEPTH_TEST);
+            break;
+        case DepthtestMode_Disabled:
+        default:
+            glDisable (GL_DEPTH_TEST);
+            break;
+
     }
 
-    if (this->m_pass.cullmode == "nocull") {
-        glDisable (GL_CULL_FACE);
-    } else {
-        glEnable (GL_CULL_FACE);
+    switch (this->m_pass.cullmode) {
+        case CullingMode_Normal:
+            glEnable (GL_CULL_FACE);
+            break;
+
+        case CullingMode_Disable:
+        default:
+            glDisable (GL_CULL_FACE);
+            break;
     }
 
-    if (this->m_pass.depthwrite == "disabled") {
-        glDepthMask (false);
-    } else {
-        glDepthMask (true);
+    switch (this->m_pass.depthwrite) {
+        case DepthwriteMode_Enabled:
+            glDepthMask (true);
+            break;
+
+        case DepthwriteMode_Disabled:
+        default:
+            glDepthMask (false);
+            break;
     }
 }
 
@@ -322,11 +341,11 @@ void CPass::setViewProjectionMatrix (const glm::mat4* viewProjection) {
     this->m_viewProjectionMatrix = viewProjection;
 }
 
-void CPass::setBlendingMode (std::string blendingmode) {
-    this->m_blendingmode = std::move(blendingmode);
+void CPass::setBlendingMode (BlendingMode blendingmode) {
+    this->m_blendingmode = blendingmode;
 }
 
-const std::string& CPass::getBlendingMode () const {
+BlendingMode CPass::getBlendingMode () const {
     return this->m_blendingmode;
 }
 

src/WallpaperEngine/Render/Objects/Effects/CPass.h

@@ -3,6 +3,7 @@
 #include <glm/gtc/type_ptr.hpp>
 #include <utility>
 
+#include "WallpaperEngine/Data/Model/Material.h"
 #include "WallpaperEngine/Assets/ITexture.h"
 #include "WallpaperEngine/Render/CFBO.h"
 #include "WallpaperEngine/Render/CFBOProvider.h"
@@ -37,8 +38,8 @@ class CPass final : public Helpers::CContextAware {
     void setModelViewProjectionMatrixInverse (const glm::mat4* projection);
     void setModelMatrix (const glm::mat4* model);
     void setViewProjectionMatrix (const glm::mat4* viewProjection);
-    void setBlendingMode (std::string blendingmode);
-    [[nodiscard]] const std::string& getBlendingMode () const;
+    void setBlendingMode (BlendingMode blendingmode);
+    [[nodiscard]] BlendingMode getBlendingMode () const;
     [[nodiscard]] std::shared_ptr<const CFBO> resolveFBO (const std::string& name) const;
 
     [[nodiscard]] std::shared_ptr<const CFBOProvider> getFBOProvider () const;
@@ -163,7 +164,7 @@ class CPass final : public Helpers::CContextAware {
     std::vector<AttribEntry*> m_attribs = {};
     std::map<std::string, UniformEntry*> m_uniforms = {};
     std::map<std::string, ReferenceUniformEntry*> m_referenceUniforms = {};
-    std::string m_blendingmode = "";
+    BlendingMode m_blendingmode = BlendingMode_Normal;
     const glm::mat4* m_modelViewProjectionMatrix;
     const glm::mat4* m_modelViewProjectionMatrixInverse;
     const glm::mat4* m_modelMatrix;

src/WallpaperEngine/Render/Wallpapers/CScene.cpp

@@ -17,6 +17,7 @@ using namespace WallpaperEngine::Render;
 using namespace WallpaperEngine::Data::Model;
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Render::Wallpapers;
+using JSON = WallpaperEngine::Data::JSON::JSON;
 
 CScene::CScene (
     const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
@@ -88,7 +89,7 @@ CScene::CScene (
     const auto bloomOrigin = glm::vec3 { sceneWidth / 2, sceneHeight / 2, 0.0f };
     const auto bloomSize = glm::vec2 { sceneWidth, sceneHeight };
 
-    const nlohmann::json bloom = {
+    const JSON bloom = {
         {"image", "models/wpenginelinux.json"},
         {"name", "bloomimagewpenginelinux"},
         {"visible", true},
@@ -98,14 +99,14 @@ CScene::CScene (
         {"size", std::to_string (bloomSize.x) + " " + std::to_string (bloomSize.y)},
         {"id", -1},
         {"effects",
-            json::array (
+            JSON::array (
                 {
                     {
                         {"file", "effects/wpenginelinux/bloomeffect.json"},
                         {"id", 15242000},
                         {"name", ""},
                         {"passes",
-                             json::array (
+                             JSON::array (
                                  {
                                      {
                                          {"constantshadervalues",