Merge branch 'xbei/option_layers' into 'main'

[REMIX-4108] Implement real-time user conf

See merge request lightspeedrtx/dxvk-remix-nv!1722

Author: xbei-nv

src/dxvk/dxvk_instance.cpp

@@ -648,6 +648,9 @@ namespace dxvk {
 
     m_config.logOptions("Effective (combined)");
 
+    RtxOptionImpl::addRtxOptionLayer(RtxOptionLayer("user.conf", RtxOptionLayer::s_runtimeOptionLayerPriority, 1.0f, 1.0f));
+    Logger::info("Set user realtime configs.");
+
     // Output environment variable info
     // Todo: This being here is kinda not great as this results in the Environment variables being parsed 3 times
     // which is quite redundant. Unfortunately this logging can't go in Config::getOption as this function is called

src/dxvk/imgui/dxvk_imgui.cpp

@@ -1099,16 +1099,13 @@ namespace dxvk {
     }
 
     ImGui::Checkbox("Save Changed Settings Only", &RtxOptions::serializeChangedOptionOnlyObject());
-    if (ImGui::Button("Save Settings")) {
+    if (IMGUI_ADD_TOOLTIP(ImGui::Button("Save Settings"), "Changes are now saved to user.conf. Use the 'Save' button in the rtx.conf layer if you want to store them there for sharing.")) {
       RtxOptions::serialize();
     }
-    ImGui::SetTooltipToLastWidgetOnHover("This will save above settings in the rtx.conf file. Some may only take effect on next launch.");
 
     ImGui::SameLine();
-    if (ImGui::Button("Reset Settings")) {
-      for (auto& optionLayer : RtxOptionImpl::getRtxOptionLayerMap()) {
-        optionLayer.setEnabled(false);
-      }
+    if (IMGUI_ADD_TOOLTIP(ImGui::Button("Reset settings"), "Reset all real-time changed settings.")) {
+      RtxOptionLayer::setResetSettings(true);
     }
 
     ImGui::SameLine();
@@ -1983,9 +1980,17 @@ namespace dxvk {
       if (ImGui::CollapsingHeader("Option Layers")) {
         ImGui::Indent();
 
-        if (ImGui::Button("Reset runtime settings")) {
-          // Remove all run-time changed settings
-          RtxOptionLayer::setResetSettings(true);
+        if (IMGUI_ADD_TOOLTIP(ImGui::Button("Disable Layers"), "Reset all settings to Default.")) {
+          for (auto& optionLayer : RtxOptionImpl::getRtxOptionLayerMap()) {
+            optionLayer.setEnabled(false);
+          }
+        }
+
+        ImGui::SameLine();
+        if (IMGUI_ADD_TOOLTIP(ImGui::Button("Enable Layers"), "Enable all option layers.")) {
+          for (auto& optionLayer : RtxOptionImpl::getRtxOptionLayerMap()) {
+            optionLayer.setEnabled(true);
+          }
         }
 
         uint32_t optionLayerCounter = 1;
@@ -2011,6 +2016,11 @@ namespace dxvk {
               optionLayer.setBlendStrengthDirty(true);
             }
 
+            const std::string optionLayerSavingText = "Save realtime changes into layer " + optionLayer.getName();
+            if (ImGui::Button(optionLayerSavingText.c_str())) {
+              RtxOptions::serializeOptionLayer(optionLayer.getName());
+            }
+
             if (ImGui::CollapsingHeader((optionLayer.getName() + " Details").c_str(), collapsingHeaderClosedFlags)) {
               ImGui::Indent();
               const std::string priorityText = "Priority: " + std::to_string(optionLayer.getPriority());

src/dxvk/rtx_render/rtx_option.cpp

@@ -490,8 +490,16 @@ namespace dxvk {
     auto& value = resolvedValue;
 
     if (changedOptionOnly) {
-      if (isDefault()) {
+      // Skip options that have no real-time changes, or the real-time value is the same as the original resolved value.
+      if (optionLayerValueQueue.begin()->second.priority != RtxOptionLayer::s_runtimeOptionLayerPriority) {
         return;
+      } else {
+        GenericValueWrapper originalValue(type);
+        resolveValue(originalValue.data, true);
+
+        if (isEqual(originalValue.data, getGenericValue(ValueType::PendingValue))) {
+          return;
+        }
       }
     }
 
@@ -742,24 +750,7 @@ namespace dxvk {
     }
   }
 
-  void RtxOptionImpl::copyOptionLayerToValue() {
-    GenericValue& optionValueTop = optionLayerValueQueue.begin()->second.value;
-    const auto& pendingValue = getGenericValue(RtxOptionImpl::ValueType::PendingValue);
-
-    if (optionLayerValueQueue.begin()->second.priority == RtxOptionLayer::s_runtimeOptionLayerPriority &&
-        !isEqual(pendingValue, optionValueTop)) {
-      // Sync the values that are changed at real-time to top option layer
-      copyValue(pendingValue, optionValueTop);
-#if RTX_OPTION_DEBUG_LOGGING
-      Logger::info(str::format("[RTX Option]: Different to pending option ", this->name,
-                               "\ntype: ", std::to_string((int) this->type),
-                               "\nbool: ", std::to_string(pendingValue.b), " ", std::to_string(optionValueTop.b),
-                               "\nint: ", std::to_string(pendingValue.i), " ", std::to_string(optionValueTop.i),
-                               "\nfloat: ", std::to_string(pendingValue.f), " ", std::to_string(optionValueTop.f)
-      ));
-#endif
-    }
-
+  void RtxOptionImpl::resolveValue(GenericValue& value, const bool ignoreChangedOption) {
     /*
       We use "throughput" here because blending (lerp) may happen across multiple layers.
       The effective result is a nested lerp chain, e.g.: v = lerp(A, lerp(B, C))
@@ -786,6 +777,11 @@ namespace dxvk {
     float throughput = 1.0f;
     // Loop layers from highest priority to lowest to lerp the value across layers base on the blend strength of layers
     for (const auto& optionLayer : optionLayerValueQueue) {
+      // Skip options with runtime priority when ignoreChangedOption is true
+      if (ignoreChangedOption && optionLayer.second.priority == RtxOptionLayer::s_runtimeOptionLayerPriority) {
+        continue;
+      }
+
       if (type == OptionType::Float || type == OptionType::Vector2 || type == OptionType::Vector3 || type == OptionType::Vector4) {
         // Stop when the blend strength is larger than 1, because lerp(a, b, 1.0f) => b, we don't need to loop lower priority values
         if (optionLayer.second.blendStrength >= 1.0f) {
@@ -804,7 +800,7 @@ namespace dxvk {
     }
 
     // Copy to resolvedValue
-    copyValue(optionValue.data, resolvedValue);
+    copyValue(optionValue.data, value);
   }
 
   bool RtxOptionImpl::writeMarkdownDocumentation(const char* outputMarkdownFilePath) {
@@ -1025,7 +1021,7 @@ Tables below enumerate all the options and their defaults set by RTX Remix. Note
     : m_configName(configPath)
     , m_enabled(true)
     , m_dirty(false)
-    , m_priority(priority + s_userOptionLayerOffset)
+    , m_priority(priority)
     , m_blendStrength(blendStrength)
     , m_blendThreshold(blendThreshold)
     , m_config(Config::getOptionLayerConfig(configPath)) {
@@ -1034,6 +1030,9 @@ Tables below enumerate all the options and their defaults set by RTX Remix. Note
                              "\nPriority: ", std::to_string(m_priority),
                              "\nStrength: ", std::to_string(m_blendStrength)));
 #endif
+    if (priority != RtxOptionLayer::s_runtimeOptionLayerPriority) {
+      m_priority += s_userOptionLayerOffset;
+    }
   }
 
   RtxOptionLayer::RtxOptionLayer(const Config& config, const std::string& configName, const uint32_t priority, const float blendStrength, const float blendThreshold)

src/dxvk/rtx_render/rtx_option.h

@@ -231,7 +231,7 @@ namespace dxvk {
     std::string genericValueToString(ValueType valueType) const;
     std::string genericValueToString(const GenericValue& value) const;
     void copyValue(const GenericValue& source, GenericValue& target);
-    void copyOptionLayerToValue();
+    void resolveValue(GenericValue& value, const bool ignoreChangedOption);
     void addWeightedValue(const GenericValue& source, const float weight, GenericValue& target);
 
     void readValue(const Config& options, const std::string& fullName, GenericValue& value);
@@ -350,12 +350,6 @@ namespace dxvk {
       pImpl->clampValue(RtxOptionImpl::ValueType::Value);
       // Mark the option as dirty so that the onChange callback is invoked, even though the value already changed mid frame.
       pImpl->markDirty();
-
-      // If the top layer is not already the runtime option layer, insert a new runtime option layer with maximum priority.
-      // Actual promotion to the active value occurs in applyPendingValuesOptionLayers().
-      if (pImpl->optionLayerValueQueue.begin()->second.priority != RtxOptionLayer::s_runtimeOptionLayerPriority) {
-        pImpl->insertOptionLayerValue(pImpl->resolvedValue, RtxOptionLayer::s_runtimeOptionLayerPriority, 1.0f, 1.0f);
-      }
     }
 
     template<typename = std::enable_if_t<std::is_same_v<T, fast_unordered_set>>>
@@ -532,7 +526,7 @@ namespace dxvk {
       dirtyOptionsVector.reserve(dirtyOptions.size());
       {
         for (auto& rtxOption : dirtyOptions) {
-          rtxOption.second->copyOptionLayerToValue();
+          rtxOption.second->resolveValue(rtxOption.second->resolvedValue, false);
           dirtyOptionsVector.push_back(rtxOption.second);
         }
       }

src/dxvk/rtx_render/rtx_options.h

@@ -1269,14 +1269,20 @@ namespace dxvk {
 
     static void resetUpscaler();
 
-    inline static const std::string kRtxConfigFilePath = "rtx.conf";
+    inline static const std::string kRtxConfigFilePath = "user.conf";
 
     static void serialize() {
       Config newConfig;
       RtxOption<bool>::writeOptions(newConfig, serializeChangedOptionOnly());
       Config::serializeCustomConfig(newConfig, kRtxConfigFilePath, "rtx.");
     }
 
+    static void serializeOptionLayer(const std::string& optionLayerName) {
+      Config newConfig;
+      RtxOption<bool>::writeOptions(newConfig, serializeChangedOptionOnly());
+      Config::serializeCustomConfig(newConfig, optionLayerName, "rtx.");
+    }
+
     static void reset() {
       RtxOption<bool>::resetOptions();
     }