Added support for overriding external preset overrides?!? without restarting

OptiScaler/State.h

@@ -178,6 +178,7 @@ class State
     // DLSS
     bool dlssPresetsOverriddenExternally = false;
     bool dlssPresetsOverridenByOpti = false;
+    uint32_t dlssRenderPresetExternal = 0;
     uint32_t dlssRenderPresetDLAA = 0;
     uint32_t dlssRenderPresetUltraQuality = 0;
     uint32_t dlssRenderPresetQuality = 0;
@@ -188,6 +189,7 @@ class State
     // DLSSD
     bool dlssdPresetsOverriddenExternally = false;
     bool dlssdPresetsOverridenByOpti = false;
+    uint32_t dlssdRenderPresetExternal = 0;
     uint32_t dlssdRenderPresetDLAA = 0;
     uint32_t dlssdRenderPresetUltraQuality = 0;
     uint32_t dlssdRenderPresetQuality = 0;

OptiScaler/menu/menu_common.cpp

@@ -131,6 +131,7 @@ static bool updateNoticeVisible = false;
 static std::string updateNoticeTag;
 static std::string updateNoticeUrl;
 static float lastMenuScale = 0.0f;
+static CustomOptional<uint32_t> comboPreset { 0 };
 
 template <typename T, size_t N> struct RingBuffer
 {
@@ -1235,6 +1236,153 @@ template <HasDefaultValue B> void MenuCommon::AddResourceBarrier(std::string nam
     }
 }
 
+static uint32_t GetPresetIndex(IFeature* feature, bool dlssd = false)
+{
+    auto ratio = (float) feature->TargetWidth() / (float) feature->RenderWidth();
+
+    if (!dlssd)
+    {
+        if (State::Instance().dlssPresetsOverridenByOpti)
+        {
+            LOG_DEBUG("DLSS Presets overridden by Opti, using Opti preset indices with ratio: {}", ratio);
+
+            if (ratio <= (Config::Instance()->QualityRatio_UltraPerformance.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->RenderPresetForAll.value_or(
+                    Config::Instance()->RenderPresetUltraPerformance.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Performance.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->RenderPresetForAll.value_or(
+                    Config::Instance()->RenderPresetPerformance.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Balanced.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->RenderPresetForAll.value_or(
+                    Config::Instance()->RenderPresetBalanced.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Quality.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->RenderPresetForAll.value_or(
+                    Config::Instance()->RenderPresetQuality.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_UltraQuality.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->RenderPresetForAll.value_or(
+                    Config::Instance()->RenderPresetUltraQuality.value_or_default());
+            }
+            else
+            {
+                return Config::Instance()->RenderPresetForAll.value_or(
+                    Config::Instance()->RenderPresetDLAA.value_or_default());
+            }
+        }
+        else if (State::Instance().dlssPresetsOverriddenExternally)
+        {
+            LOG_DEBUG("DLSS Presets overridden externally, using external preset index: {}",
+                      State::Instance().dlssRenderPresetExternal);
+
+            return State::Instance().dlssRenderPresetExternal;
+        }
+        else
+        {
+            if (ratio <= (Config::Instance()->QualityRatio_UltraPerformance.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssRenderPresetUltraPerformance;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Performance.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssRenderPresetPerformance;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Balanced.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssRenderPresetBalanced;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Quality.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssRenderPresetQuality;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_UltraQuality.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssRenderPresetUltraQuality;
+            }
+            else
+            {
+                return State::Instance().dlssRenderPresetDLAA;
+            }
+        }
+    }
+    else
+    {
+        if (State::Instance().dlssdPresetsOverridenByOpti)
+        {
+            if (ratio <= (Config::Instance()->QualityRatio_UltraPerformance.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->DLSSDRenderPresetForAll.value_or(
+                    Config::Instance()->DLSSDRenderPresetUltraPerformance.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Performance.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->DLSSDRenderPresetForAll.value_or(
+                    Config::Instance()->DLSSDRenderPresetPerformance.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Balanced.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->DLSSDRenderPresetForAll.value_or(
+                    Config::Instance()->DLSSDRenderPresetBalanced.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Quality.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->DLSSDRenderPresetForAll.value_or(
+                    Config::Instance()->DLSSDRenderPresetQuality.value_or_default());
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_UltraQuality.value_or_default() + 0.01f))
+            {
+                return Config::Instance()->DLSSDRenderPresetForAll.value_or(
+                    Config::Instance()->DLSSDRenderPresetUltraQuality.value_or_default());
+            }
+            else
+            {
+                return Config::Instance()->DLSSDRenderPresetForAll.value_or(
+                    Config::Instance()->DLSSDRenderPresetDLAA.value_or_default());
+            }
+        }
+        else if (State::Instance().dlssdPresetsOverriddenExternally)
+        {
+            return State::Instance().dlssdRenderPresetExternal;
+        }
+        else
+        {
+            if (ratio <= (Config::Instance()->QualityRatio_UltraPerformance.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssdRenderPresetUltraPerformance;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Performance.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssdRenderPresetPerformance;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Balanced.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssdRenderPresetBalanced;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_Quality.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssdRenderPresetQuality;
+            }
+            else if (ratio <= (Config::Instance()->QualityRatio_UltraQuality.value_or_default() + 0.01f))
+            {
+                return State::Instance().dlssdRenderPresetUltraQuality;
+            }
+            else
+            {
+                return State::Instance().dlssdRenderPresetDLAA;
+            }
+        }
+    }
+
+    return 0;
+}
+
 constexpr uint32_t NV_PRESET_LATEST = 0x00FFFFFF;
 
 // TODO: disable presets based on the detected DLSS version
@@ -1788,6 +1936,14 @@ bool MenuCommon::RenderMenu()
                 auto dllPath = Util::DllPath().parent_path() / "dlssg_to_fsr3_amd_is_better.dll";
                 state.NukemsFilesAvailable = gExists.Get(dllPath);
 
+                if (State::Instance().currentFeature != nullptr)
+                {
+                    if (State::Instance().currentFeature->Name() == "DLSSD")
+                        comboPreset = config->DLSSDRenderPresetForAll.value_or_default();
+                    else if (State::Instance().currentFeature->Name() == "DLSS")
+                        comboPreset = config->RenderPresetForAll.value_or_default();
+                }
+
                 if (pfn_ClipCursor_hooked)
                 {
                     _ssRatio = 0;
@@ -3224,8 +3380,8 @@ bool MenuCommon::RenderMenu()
                             ImGui::TextColored(ImVec4(1.f, 0.8f, 0.f, 1.f), "Presets are overridden externally");
                             ShowHelpMarker("This usually happens due to using tools\n"
                                            "such as Nvidia App or Nvidia Inspector");
-                            ImGui::Text("Selecting setting below will disable that external override\n"
-                                        "but you need to Save INI and restart the game");
+                            // ImGui::Text("Selecting setting below will disable that external override\n"
+                            //             "but you need to Save INI and restart the game");
 
                             ImGui::Spacing();
                         }
@@ -3240,10 +3396,20 @@ bool MenuCommon::RenderMenu()
                                            "Override to potentially improve image quality\n"
                                            "Press apply after enable/disable");
 
-                            ImGui::BeginDisabled(!config->DLSSDRenderPresetOverride.value_or_default() || overridden);
+                            /*
+                            auto currentPresetIndex = GetPresetIndex(currentFeature, true);
+
+                            if (currentPresetIndex == 0)
+                                ImGui::Text("Current Preset: Default");
+                            else
+                                ImGui::Text("Current Preset: %c", 64 + currentPresetIndex);
+                            */
+
+                            ImGui::BeginDisabled(
+                                !config->DLSSDRenderPresetOverride.value_or_default() /*|| overridden*/);
                             ImGui::PushItemWidth(135.0f * menuResScale);
 
-                            AddDLSSDRenderPreset("Override Preset", &config->DLSSDRenderPresetForAll);
+                            AddDLSSDRenderPreset("Override Preset", &comboPreset);
 
                             ImGui::PopItemWidth();
                             ImGui::EndDisabled();
@@ -3258,11 +3424,20 @@ bool MenuCommon::RenderMenu()
                                            "Override to potentially improve image quality\n"
                                            "Press apply after enable/disable");
 
-                            ImGui::BeginDisabled(!config->RenderPresetOverride.value_or_default() || overridden);
+                            /*
+                            auto currentPresetIndex = GetPresetIndex(currentFeature, false);
+
+                            if (currentPresetIndex == 0)
+                                ImGui::Text("Current Preset: Default");
+                            else
+                                ImGui::Text("Current Preset: %c", 64 + currentPresetIndex);
+                            */
+
+                            ImGui::BeginDisabled(!config->RenderPresetOverride.value_or_default() /*|| overridden*/);
 
                             ImGui::PushItemWidth(135.0f * menuResScale);
 
-                            AddDLSSRenderPreset("Override Preset", &config->RenderPresetForAll);
+                            AddDLSSRenderPreset("Override Preset", &comboPreset);
 
                             ImGui::PopItemWidth();
                             ImGui::EndDisabled();
@@ -3272,10 +3447,19 @@ bool MenuCommon::RenderMenu()
 
                         if (ImGui::Button("Apply Changes"))
                         {
+                            LOG_DEBUG("Applying DLSS/DLSSD preset override changes, preset index: {}",
+                                      comboPreset.value_or_default());
+
                             if (usesDlssd)
+                            {
+                                config->DLSSDRenderPresetForAll = comboPreset.value_or_default();
                                 state.newBackend = "dlssd";
+                            }
                             else
+                            {
+                                config->RenderPresetForAll = comboPreset.value_or_default();
                                 state.newBackend = currentBackend;
+                            }
 
                             MARK_ALL_BACKENDS_CHANGED();
                         }

OptiScaler/nvapi/NvApiHooks.cpp

@@ -62,20 +62,28 @@ NvAPI_Status __stdcall NvApiHooks::hkNvAPI_DRS_GetSetting(NvDRSSessionHandle hSe
     {
         if (settingId == NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_ID)
         {
-            if (Config::Instance()->RenderPresetOverride.value_or_default())
-                pSetting->u32CurrentValue = NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
-            else
-                State::Instance().dlssPresetsOverriddenExternally =
-                    pSetting->u32CurrentValue != NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
+            State::Instance().dlssRenderPresetExternal = pSetting->u32CurrentValue;
+
+            State::Instance().dlssPresetsOverriddenExternally =
+                pSetting->u32CurrentValue != NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
+
+            // Report no override, we will handle presets from now on
+            pSetting->u32CurrentValue = NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
+
+            LOG_DEBUG("DLSS External override: {}", State::Instance().dlssRenderPresetExternal);
         }
 
         if (settingId == NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_ID)
         {
-            if (Config::Instance()->RenderPresetOverride.value_or_default())
-                pSetting->u32CurrentValue = NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
-            else
-                State::Instance().dlssdPresetsOverriddenExternally =
-                    pSetting->u32CurrentValue != NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
+            State::Instance().dlssdRenderPresetExternal = pSetting->u32CurrentValue;
+
+            State::Instance().dlssdPresetsOverriddenExternally =
+                pSetting->u32CurrentValue != NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
+
+            // Report no override, we will handle presets from now on
+            pSetting->u32CurrentValue = NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF;
+
+            LOG_DEBUG("DLSSD External override: {}", State::Instance().dlssdRenderPresetExternal);
         }
     }
 

OptiScaler/upscalers/dlss/DLSSFeature.cpp

@@ -166,6 +166,15 @@ void DLSSFeature::ProcessInitParams(NVSDK_NGX_Parameter* InParameters)
 
         if (Config::Instance()->RenderPresetOverride.value_or_default())
         {
+            LOG_DEBUG("RenderPresetForAll: {}", Config::Instance()->RenderPresetForAll.value_or_default());
+            LOG_DEBUG("RenderPresetDLAA: {}", Config::Instance()->RenderPresetDLAA.value_or_default());
+            LOG_DEBUG("RenderPresetUltraQuality: {}", Config::Instance()->RenderPresetUltraQuality.value_or_default());
+            LOG_DEBUG("RenderPresetQuality: {}", Config::Instance()->RenderPresetQuality.value_or_default());
+            LOG_DEBUG("RenderPresetBalanced: {}", Config::Instance()->RenderPresetBalanced.value_or_default());
+            LOG_DEBUG("RenderPresetPerformance: {}", Config::Instance()->RenderPresetPerformance.value_or_default());
+            LOG_DEBUG("RenderPresetUltraPerformance: {}",
+                      Config::Instance()->RenderPresetUltraPerformance.value_or_default());
+
             RenderPresetDLAA = Config::Instance()->RenderPresetForAll.value_or(
                 Config::Instance()->RenderPresetDLAA.value_or(RenderPresetDLAA));
             RenderPresetUltraQuality = Config::Instance()->RenderPresetForAll.value_or(
@@ -220,6 +229,22 @@ void DLSSFeature::ProcessInitParams(NVSDK_NGX_Parameter* InParameters)
         }
         else
         {
+            if (State::Instance().dlssPresetsOverriddenExternally)
+            {
+                InParameters->Set(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_DLAA,
+                                  State::Instance().dlssRenderPresetExternal);
+                InParameters->Set(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraQuality,
+                                  State::Instance().dlssRenderPresetExternal);
+                InParameters->Set(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Quality,
+                                  State::Instance().dlssRenderPresetExternal);
+                InParameters->Set(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Balanced,
+                                  State::Instance().dlssRenderPresetExternal);
+                InParameters->Set(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_Performance,
+                                  State::Instance().dlssRenderPresetExternal);
+                InParameters->Set(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraPerformance,
+                                  State::Instance().dlssRenderPresetExternal);
+            }
+
             InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_DLAA,
                               &State::Instance().dlssRenderPresetDLAA);
             InParameters->Get(NVSDK_NGX_Parameter_DLSS_Hint_Render_Preset_UltraQuality,

OptiScaler/upscalers/dlssd/DLSSDFeature.cpp

@@ -207,6 +207,22 @@ void DLSSDFeature::ProcessInitParams(NVSDK_NGX_Parameter* InParameters)
         }
         else
         {
+            if (State::Instance().dlssPresetsOverriddenExternally)
+            {
+                InParameters->Set("RayReconstruction.Hint.Render.Preset.DLAA",
+                                  State::Instance().dlssdRenderPresetExternal);
+                InParameters->Set("RayReconstruction.Hint.Render.Preset.UltraQuality",
+                                  State::Instance().dlssdRenderPresetExternal);
+                InParameters->Set("RayReconstruction.Hint.Render.Preset.Quality",
+                                  State::Instance().dlssdRenderPresetExternal);
+                InParameters->Set("RayReconstruction.Hint.Render.Preset.Balanced",
+                                  State::Instance().dlssdRenderPresetExternal);
+                InParameters->Set("RayReconstruction.Hint.Render.Preset.Performance",
+                                  State::Instance().dlssdRenderPresetExternal);
+                InParameters->Set("RayReconstruction.Hint.Render.Preset.UltraPerformance",
+                                  State::Instance().dlssdRenderPresetExternal);
+            }
+
             InParameters->Get("RayReconstruction.Hint.Render.Preset.DLAA", &State::Instance().dlssdRenderPresetDLAA);
             InParameters->Get("RayReconstruction.Hint.Render.Preset.UltraQuality",
                               &State::Instance().dlssdRenderPresetUltraQuality);