New Depth of Field implementation (#1773)

src/dusk/config.cpp

@@ -172,6 +172,7 @@ namespace dusk::config {
     template class ConfigImpl<f64>;
     template class ConfigImpl<std::string>;
     template class ConfigImpl<dusk::BloomMode>;
+    template class ConfigImpl<dusk::DepthOfFieldMode>;
     template class ConfigImpl<dusk::DiscVerificationState>;
     template class ConfigImpl<dusk::GameLanguage>;
     template class ConfigImpl<dusk::GyroMode>;

src/dusk/settings.cpp

@@ -60,13 +60,13 @@ UserSettings g_userSettings = {
         // Graphics
         .bloomMode {"game.bloomMode", BloomMode::Dusk},
         .bloomMultiplier {"game.bloomMultiplier", 1.0f},
+        .depthOfFieldMode{"game.depthOfFieldMode", DepthOfFieldMode::Dusk},
         .disableWaterRefraction {"game.disableWaterRefraction", false},
         .enableTextureReplacements {"game.enableTextureReplacements", true},
         .enableFrameInterpolation {"game.enableFrameInterpolation", FrameInterpMode::Off},
         .internalResolutionScale {"game.internalResolutionScale", 0},
         .shadowResolutionMultiplier {"game.shadowResolutionMultiplier", 1},
         .resampler {"game.resampler", Resampler::Bilinear},
-        .enableDepthOfField {"game.enableDepthOfField", true},
         .enableMapBackground {"game.enableMapBackground", true},
         .disableCutscenePillarboxing {"game.disableCutscenePillarboxing", false},
 
@@ -225,12 +225,12 @@ void registerSettings() {
     Register(g_userSettings.game.enableDiscordPresence);
     Register(g_userSettings.game.bloomMode);
     Register(g_userSettings.game.bloomMultiplier);
+    Register(g_userSettings.game.depthOfFieldMode);
     Register(g_userSettings.game.disableWaterRefraction);
     Register(g_userSettings.game.enableTextureReplacements);
     Register(g_userSettings.game.internalResolutionScale);
     Register(g_userSettings.game.resampler);
     Register(g_userSettings.game.shadowResolutionMultiplier);
-    Register(g_userSettings.game.enableDepthOfField);
     Register(g_userSettings.game.enableMapBackground);
     Register(g_userSettings.game.disableCutscenePillarboxing);
     Register(g_userSettings.game.enableFastIronBoots);

src/dusk/ui/graphics_tuner.cpp

@@ -52,6 +52,8 @@ int get_value(GraphicsOption option) {
         return std::clamp(
             static_cast<int>(getSettings().game.bloomMultiplier.getValue() * 100.0f + 0.5f), 0,
             100);
+    case GraphicsOption::DepthOfFieldMode:
+        return static_cast<int>(getSettings().game.depthOfFieldMode.getValue());
     }
     return 0;
 }
@@ -85,6 +87,10 @@ void set_value(GraphicsOption option, int value) {
         getSettings().game.bloomMode.setValue(static_cast<BloomMode>(std::clamp(
             value, static_cast<int>(BloomMode::Off), static_cast<int>(BloomMode::Dusk))));
         break;
+    case GraphicsOption::DepthOfFieldMode:
+        getSettings().game.depthOfFieldMode.setValue(static_cast<DepthOfFieldMode>(std::clamp(
+            value, static_cast<int>(DepthOfFieldMode::Off), static_cast<int>(DepthOfFieldMode::Dusk))));
+        break;
     case GraphicsOption::BloomMultiplier:
         getSettings().game.bloomMultiplier.setValue(std::clamp(value, 0, 100) / 100.0f);
         break;
@@ -214,6 +220,16 @@ Rml::String format_graphics_setting_value(GraphicsOption option, int value) {
             return "Dusklight";
         }
         break;
+    case GraphicsOption::DepthOfFieldMode:
+        switch (static_cast<DepthOfFieldMode>(value)) {
+        case DepthOfFieldMode::Off:
+            return "Off";
+        case DepthOfFieldMode::Classic:
+            return "Classic";
+        case DepthOfFieldMode::Dusk:
+            return "Dusklight";
+        }
+        break;
     case GraphicsOption::BloomMultiplier:
         return fmt::format("{}%", value);
     }

src/dusk/ui/graphics_tuner.hpp

@@ -45,6 +45,7 @@ enum class GraphicsOption {
     Resampler,
     BloomMode,
     BloomMultiplier,
+    DepthOfFieldMode,
 };
 
 Rml::String format_graphics_setting_value(GraphicsOption option, int value);

src/dusk/ui/preset.cpp

@@ -14,6 +14,7 @@ void applyPresetClassic() {
     auto& s = getSettings();
     s.video.lockAspectRatio.setValue(true);
     s.game.bloomMode.setValue(BloomMode::Classic);
+    s.game.depthOfFieldMode.setValue(DepthOfFieldMode::Classic);
     s.game.enableAchievementToasts.setValue(false);
     s.game.enableControllerToasts.setValue(false);
     s.game.internalResolutionScale.setValue(1);
@@ -44,6 +45,7 @@ void applyPresetDusk() {
     s.game.enableFrameInterpolation.setValue(FrameInterpMode::Unlimited);
     s.game.sunsSong.setValue(true);
     s.game.bloomMode.setValue(BloomMode::Dusk);
+    s.game.depthOfFieldMode.setValue(DepthOfFieldMode::Dusk);
     s.game.internalResolutionScale.setValue(0);
     s.game.shadowResolutionMultiplier.setValue(4);
     s.game.enableGyroAim.setValue(true);

src/dusk/ui/settings.cpp

@@ -370,6 +370,9 @@ const Rml::String kBloomHelpText =
     "a higher-quality bloom pass.";
 const Rml::String kBloomBrightnessHelpText =
     "Configure bloom intensity. Higher values make bright areas glow more strongly.";
+const Rml::String kDepthOfFieldHelpText =
+    "Configure the post-processing depth-of-field effect. Classic uses the original depth-of-field pass;"
+    " Dusklight uses a higher-quality depth-of-field pass.";
 const Rml::String kUnlockFramerateHelpText =
     "<br/>Uses inter-frame interpolation to enable higher frame rates.<br/><br/>May introduce minor "
     "visual artifacts or animation glitches.";
@@ -842,7 +845,18 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .valueMax = 100,
                 .defaultValue = 100,
                 .step = 10,
-            }, mPrelaunch);
+            },
+            mPrelaunch);
+        graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.depthOfFieldMode,
+            GraphicsTunerProps{
+                .option = GraphicsOption::DepthOfFieldMode,
+                .title = "Depth of Field",
+                .helpText = kDepthOfFieldHelpText,
+                .valueMin = static_cast<int>(DepthOfFieldMode::Off),
+                .valueMax = static_cast<int>(DepthOfFieldMode::Dusk),
+                .defaultValue = static_cast<int>(DepthOfFieldMode::Classic),
+            },
+            mPrelaunch);
 
         leftPane.add_section("Rendering");
         config_bool_select(leftPane, rightPane, getSettings().game.enableTextureReplacements,
@@ -884,11 +898,6 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         config_int_select(leftPane, rightPane, getSettings().video.maxFrameRate,
             "Framerate Cap", "Limit the framerate to the specified value.", 30, 540, 1,
             [] { return getSettings().game.enableFrameInterpolation.getValue() != FrameInterpMode::Capped; });
-        config_bool_select(leftPane, rightPane, getSettings().game.enableDepthOfField,
-            {
-                .key = "Enable Depth of Field",
-                .helpText = "Render a blurring effect for out-of-focus areas in some situations. May impact performance."
-            });
         config_bool_select(leftPane, rightPane, getSettings().game.enableMapBackground,
             {
                 .key = "Enable Mini-Map Shadows",