Add "Bloom Mode" config option (Off, Classic, Dusk)

include/dusk/config_var.hpp

@@ -146,6 +146,12 @@ concept ConfigValue =
 template <ConfigValue T>
 const ConfigImplBase* GetConfigImpl();
 
+template <typename T>
+struct ConfigEnumRange {
+    static constexpr auto min = std::numeric_limits<std::underlying_type_t<T>>::min();
+    static constexpr auto max = std::numeric_limits<std::underlying_type_t<T>>::max();
+};
+
 /**
  * \brief A CVar storing values.
  *
@@ -189,6 +195,11 @@ public:
         }
     }
 
+    [[nodiscard]] constexpr const T& getDefaultValue() const noexcept {
+        checkRegistered();
+        return defaultValue;
+    }
+
     /**
      * \brief Change the value of a CVar.
      *

include/dusk/settings.h

@@ -7,6 +7,20 @@ namespace dusk {
 
 using namespace config;
 
+enum class BloomMode : int {
+    Off = 0,
+    Classic = 1,
+    Dusk = 2,
+};
+
+namespace config {
+template <>
+struct ConfigEnumRange<BloomMode> {
+    static constexpr auto min = BloomMode::Off;
+    static constexpr auto max = BloomMode::Dusk;
+};
+}
+
 // Persistent user settings
 
 struct UserSettings {
@@ -53,7 +67,7 @@ struct UserSettings {
         ConfigVar<bool> invertCameraXAxis;
 
         // Graphics
-        ConfigVar<bool> enableBloom;
+        ConfigVar<BloomMode> bloomMode;
         ConfigVar<bool> enableWaterRefraction;
         ConfigVar<bool> enableFrameInterpolation;
         ConfigVar<int> shadowResolutionMultiplier;

src/dusk/config.cpp

@@ -5,6 +5,7 @@
 
 #include "aurora/lib/logging.hpp"
 #include "dusk/io.hpp"
+#include "dusk/settings.h"
 
 #include <limits>
 #include <string>
@@ -37,9 +38,24 @@ const ConfigImplBase* ConfigVarBase::getImpl() const noexcept {
     return impl;
 }
 
+template <typename T>
+static T sanitizeEnumValue(const ConfigVar<T>& cVar, T value) {
+    if constexpr (std::is_enum_v<T>) {
+        using Underlying = std::underlying_type_t<T>;
+        const Underlying raw = static_cast<Underlying>(value);
+        const Underlying min = static_cast<Underlying>(ConfigEnumRange<T>::min);
+        const Underlying max = static_cast<Underlying>(ConfigEnumRange<T>::max);
+        if (raw < min || raw > max) {
+            return cVar.getDefaultValue();
+        }
+    }
+
+    return value;
+}
+
 template<ConfigValue T>
 void ConfigImpl<T>::loadFromJson(ConfigVar<T>& cVar, const json& jsonValue) {
-    cVar.setValue(jsonValue.get<T>(), false);
+    cVar.setValue(sanitizeEnumValue(cVar, jsonValue.get<T>()), false);
 }
 
 template<ConfigValue T>
@@ -85,6 +101,28 @@ static void loadFromArgImpl(ConfigVar<std::string>& cVar, const std::string_view
     cVar.setOverrideValue(std::string(stringValue));
 }
 
+template<ConfigValue T> requires std::is_enum_v<T>
+static void loadFromArgImpl(ConfigVar<T>& cVar, const std::string_view stringValue) {
+    using Underlying = std::underlying_type_t<T>;
+    const std::string str(stringValue);
+
+    if constexpr (std::is_signed_v<Underlying>) {
+        const auto result = std::stoll(str);
+        if (result >= std::numeric_limits<Underlying>::min() && result <= std::numeric_limits<Underlying>::max()) {
+            cVar.setOverrideValue(sanitizeEnumValue(cVar, static_cast<T>(result)));
+        } else {
+            throw std::out_of_range("Value is too large");
+        }
+    } else {
+        const auto result = std::stoull(str);
+        if (result <= std::numeric_limits<Underlying>::max()) {
+            cVar.setOverrideValue(sanitizeEnumValue(cVar, static_cast<T>(result)));
+        } else {
+            throw std::out_of_range("Value is too large");
+        }
+    }
+}
+
 template<ConfigValue T>
 void ConfigImpl<T>::loadFromArg(ConfigVar<T>& cVar, const std::string_view stringValue) {
     loadFromArgImpl(cVar, stringValue);
@@ -115,6 +153,7 @@ namespace dusk::config {
     template class ConfigImpl<f32>;
     template class ConfigImpl<f64>;
     template class ConfigImpl<std::string>;
+    template class ConfigImpl<dusk::BloomMode>;
 }
 
 void dusk::config::Register(ConfigVarBase& configVar) {

src/dusk/imgui/ImGuiFirstRunPreset.cpp

@@ -12,11 +12,13 @@ namespace dusk {
 static void ApplyPresetClassic() {
     auto& s = getSettings();
     s.video.lockAspectRatio.setValue(true);
+    s.game.bloomMode.setValue(BloomMode::Classic);
     VILockAspectRatio(defaultAspectRatioW, defaultAspectRatioH);
 }
 
 static void ApplyPresetHD() {
     auto& s = getSettings();
+    s.game.bloomMode.setValue(BloomMode::Classic);
     s.game.hideTvSettingsScreen.setValue(true);
     s.game.skipWarningScreen.setValue(true);
     s.game.noReturnRupees.setValue(true);
@@ -37,6 +39,7 @@ static void ApplyPresetDusk() {
     s.game.instantSaves.setValue(true);
     s.game.midnasLamentNonStop.setValue(true);
     s.game.enableFrameInterpolation.setValue(true);
+    s.game.bloomMode.setValue(BloomMode::Dusk);
 }
 
 // =========================================================================

src/dusk/imgui/ImGuiMenuGame.cpp

@@ -62,7 +62,21 @@ namespace dusk {
                     config::Save();
                 }
 
-                config::ImGuiCheckbox("Native Bloom", getSettings().game.enableBloom);
+                constexpr const char* bloomModeNames[] = {"Off", "Classic", "Dusk"};
+                int bloomMode = static_cast<int>(getSettings().game.bloomMode.getValue());
+                if (ImGui::BeginCombo("Bloom", bloomModeNames[bloomMode])) {
+                    for (int i = 0; i < IM_ARRAYSIZE(bloomModeNames); i++) {
+                        const bool selected = bloomMode == i;
+                        if (ImGui::Selectable(bloomModeNames[i], selected)) {
+                            getSettings().game.bloomMode.setValue(static_cast<BloomMode>(i));
+                            config::Save();
+                        }
+                        if (selected) {
+                            ImGui::SetItemDefaultFocus();
+                        }
+                    }
+                    ImGui::EndCombo();
+                }
 
                 config::ImGuiCheckbox("Enable Water Refraction", getSettings().game.enableWaterRefraction);
 

src/dusk/settings.cpp

@@ -41,7 +41,7 @@ UserSettings g_userSettings = {
         .invertCameraXAxis {"game.invertCameraXAxis", false},
 
         // Graphics
-        .enableBloom {"game.enableBloom", true},
+        .bloomMode {"game.bloomMode", BloomMode::Classic},
         .enableWaterRefraction {"game.enableWaterRefraction", true},
         .enableFrameInterpolation = {"game.enableFrameInterpolation", false},
         .shadowResolutionMultiplier {"game.shadowResolutionMultiplier", 1},
@@ -113,7 +113,7 @@ void registerSettings() {
     Register(g_userSettings.game.instantSaves);
     Register(g_userSettings.game.enableMirrorMode);
     Register(g_userSettings.game.invertCameraXAxis);
-    Register(g_userSettings.game.enableBloom);
+    Register(g_userSettings.game.bloomMode);
     Register(g_userSettings.game.enableWaterRefraction);
     Register(g_userSettings.game.shadowResolutionMultiplier);
     Register(g_userSettings.game.enableFastIronBoots);

src/m_Do/m_Do_graphic.cpp

@@ -1501,13 +1501,11 @@ void mDoGph_gInf_c::bloom_c::draw2() {
 
 void mDoGph_gInf_c::bloom_c::draw() {
     ZoneScoped;
-    if (!dusk::getSettings().game.enableBloom) {
+    if (dusk::getSettings().game.bloomMode.getValue() == dusk::BloomMode::Dusk) {
+        draw2();
         return;
     }
-
-    static bool s_bloom2 = false;
-    if (s_bloom2) {
-        draw2();
+    if (dusk::getSettings().game.bloomMode.getValue() != dusk::BloomMode::Classic) {
         return;
     }