Merge branch 'dev/ralston/enhancements_progress_hud_main' into 'main'

Enhancements Progress HUD

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

Author: Riley Alston

src/dxvk/imgui/dxvk_imgui.cpp

@@ -814,13 +814,13 @@ namespace dxvk {
     };
 
     auto common = ctx->getCommonObjects();
-    static RtxQuickAction sQuickAction = common->getSceneManager().areReplacementsLoaded() ? RtxQuickAction::kRtxOnEnhanced : RtxQuickAction::kRtxOn;
+    static RtxQuickAction sQuickAction = common->getSceneManager().areAllReplacementsLoaded() ? RtxQuickAction::kRtxOnEnhanced : RtxQuickAction::kRtxOn;
 
     if (ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_KeypadAdd))) {
       sQuickAction = (RtxQuickAction) ((sQuickAction + 1) % RtxQuickAction::kCount);
 
       // Skip over the enhancements quick option if no replacements are loaded
-      if(!common->getSceneManager().areReplacementsLoaded() && sQuickAction == RtxQuickAction::kRtxOnEnhanced)
+      if(!common->getSceneManager().areAllReplacementsLoaded() && sQuickAction == RtxQuickAction::kRtxOnEnhanced)
         sQuickAction = (RtxQuickAction) ((sQuickAction + 1) % RtxQuickAction::kCount);
 
       switch (sQuickAction) {
@@ -1364,7 +1364,7 @@ namespace dxvk {
 
     ImGui::Dummy(ImVec2(0.0f, 5.0f));
 
-    ImGui::BeginDisabled(!common->getSceneManager().areReplacementsLoaded());
+    ImGui::BeginDisabled(!common->getSceneManager().areAllReplacementsLoaded());
 
     m_userGraphicsSettingChanged |= ImGui::Checkbox("Enable All Enhanced Assets", &RtxOptions::Get()->enableReplacementAssetsObject());
 
@@ -1401,10 +1401,10 @@ namespace dxvk {
     auto common = ctx->getCommonObjects();
     const auto& pipelineManager = common->pipelineManager();
 
-    // Add needed Hud Messages
-
     std::vector<HudMessage> hudMessages;
 
+    // Add Shader Compilation HUD messages
+
     uint32_t asyncShaderCompilationCount = 0;
     if (RtxOptions::Shader::enableAsyncCompilation()) {
       asyncShaderCompilationCount = pipelineManager.remixShaderCompilationCount();
@@ -1416,8 +1416,55 @@ namespace dxvk {
       hudMessages.emplace_back(std::move(compilationText), "This may take some time if shaders are not cached yet.\nRemix will not render properly until compilation is finished.");
     }
 
-    if (common->getSceneManager().areReplacementsLoading()) {
-      hudMessages.emplace_back("Loading enhancements", std::nullopt);
+    // Add Enhancement Loading HUD messages
+
+    const auto replacementStates = common->getSceneManager().getReplacementStates();
+    std::string replacementLoadingSubtext;
+    std::uint32_t loadingReplacementStateCount{ 0U };
+
+    for (std::size_t i{ 0U }; i < replacementStates.size(); ++i) {
+      auto&& replacementState = replacementStates[i];
+
+      // Add a newline when reporting on more than one mod in a loading state
+
+      if (loadingReplacementStateCount != 0) {
+        replacementLoadingSubtext += '\n';
+      }
+
+      // Hide individual mod progress messages beyond a requested amount
+      // Note: This ensures if for some reason there are a significant amount of mods in place that the screen will not be filled with progress hud messages.
+
+      constexpr std::size_t maxModProgressCount{ 4 };
+
+      if (loadingReplacementStateCount >= maxModProgressCount) {
+        replacementLoadingSubtext += str::format(replacementStates.size() - maxModProgressCount, " more hidden...");
+
+        break;
+      }
+
+      // Set the progress message if the mod is in a loading state and increment the number of currently loading mods
+
+      switch (replacementState.progressState) {
+      case Mod::ProgressState::OpeningUSD: replacementLoadingSubtext += str::format("Opening USD"); break;
+      case Mod::ProgressState::ProcessingMaterials: replacementLoadingSubtext += str::format("Processing Materials (", replacementState.progressCount, " processed)"); break;
+      case Mod::ProgressState::ProcessingMeshes: replacementLoadingSubtext += str::format("Processing Meshes (", replacementState.progressCount, " processed)"); break;
+      case Mod::ProgressState::ProcessingLights: replacementLoadingSubtext += str::format("Processing Lights (", replacementState.progressCount, " processed)"); break;
+      }
+
+      if (
+        replacementState.progressState == Mod::ProgressState::OpeningUSD ||
+        replacementState.progressState == Mod::ProgressState::ProcessingMaterials ||
+        replacementState.progressState == Mod::ProgressState::ProcessingMeshes ||
+        replacementState.progressState == Mod::ProgressState::ProcessingLights
+      ) {
+        ++loadingReplacementStateCount;
+      }
+    }
+
+    assert((loadingReplacementStateCount == 0U) == replacementLoadingSubtext.empty());
+
+    if (loadingReplacementStateCount != 0U) {
+      hudMessages.emplace_back("Loading enhancements", replacementLoadingSubtext);
     }
 
     // Draw Hud Messages
@@ -2113,11 +2160,11 @@ namespace dxvk {
   }
 
   void ImGUI::showEnhancementsTab(const Rc<DxvkContext>& ctx) {
-    if (!ctx->getCommonObjects()->getSceneManager().areReplacementsLoaded()) {
+    if (!ctx->getCommonObjects()->getSceneManager().areAllReplacementsLoaded()) {
       ImGui::Text("No USD enhancements detected, the following options have been disabled.  See documentation for how to use enhancements with Remix.");
     }
 
-    ImGui::BeginDisabled(!ctx->getCommonObjects()->getSceneManager().areReplacementsLoaded());
+    ImGui::BeginDisabled(!ctx->getCommonObjects()->getSceneManager().areAllReplacementsLoaded());
     ImGui::Checkbox("Enable Enhanced Assets", &RtxOptions::Get()->enableReplacementAssetsObject());
     {
       ImGui::Indent();

src/dxvk/imgui/dxvk_imgui_capture.cpp

@@ -57,7 +57,7 @@ namespace dxvk {
   void ImGuiCapture::show(const Rc<DxvkContext>& ctx) {
     auto capturer = ctx->getCommonObjects()->capturer();
     const bool disableCapture =
-      ctx->getCommonObjects()->getSceneManager().areReplacementsLoaded() &&
+      ctx->getCommonObjects()->getSceneManager().areAllReplacementsLoaded() &&
       RtxOptions::Get()->getEnableAnyReplacements();
     constexpr auto headerFlagsDefaultOpen = kCollapsingHeaderFlags | ImGuiTreeNodeFlags_DefaultOpen;
     if(ImGui::CollapsingHeader("USD Scene Capture", headerFlagsDefaultOpen)) {

src/dxvk/rtx_render/rtx_asset_replacer.cpp

@@ -97,29 +97,25 @@ bool AssetReplacer::checkForChanges(const Rc<DxvkContext>& context) {
   return changed;
 }
 
-bool AssetReplacer::areReplacementsLoaded() const {
-  bool loaded = false;
+bool AssetReplacer::areAllReplacementsLoaded() const {
   for (auto& mod : m_modManager.mods()) {
-    loaded |= mod->state() == Mod::State::Loaded;
+    if (mod->state().progressState != Mod::ProgressState::Loaded) {
+      return false;
+    }
   }
-  return loaded;
-}
 
-bool AssetReplacer::areReplacementsLoading() const {
-  bool loading = false;
-  for (auto& mod : m_modManager.mods()) {
-    loading |= mod->state() == Mod::State::Loading;
-  }
-  return loading;
+  return true;
 }
 
-const std::string& AssetReplacer::getReplacementStatus() const {
-  // TODO: make an array?
-  for (auto& mod : m_modManager.mods()) {
-    return mod->status();
+std::vector<Mod::State> AssetReplacer::getReplacementStates() const {
+  const auto& mods = m_modManager.mods();
+  std::vector<Mod::State> modStates(mods.size());
+
+  for (auto& mod : mods) {
+    modStates.emplace_back(mod->state());
   }
-  static const std::string noReplacements("no replacements");
-  return noReplacements;
+
+  return modStates;
 }
 
 void AssetReplacer::updateSecretReplacements() {
@@ -129,7 +125,7 @@ void AssetReplacer::updateSecretReplacements() {
   m_secretReplacements.clear();
 
   for (auto& mod : m_modManager.mods()) {
-    if (mod->state() != Mod::State::Loaded) {
+    if (mod->state().progressState != Mod::ProgressState::Loaded) {
       continue;
     }
 

src/dxvk/rtx_render/rtx_asset_replacer.h

@@ -200,9 +200,11 @@ namespace dxvk {
     // returns true if the state of replacements has changed.
     bool checkForChanges(const Rc<DxvkContext>& context);
 
-    bool areReplacementsLoaded() const;
-    bool areReplacementsLoading() const;
-    const std::string& getReplacementStatus() const;
+
+    // Returns true if all replacement mods are in the loaded state, false otherwise.
+    bool areAllReplacementsLoaded() const;
+    // Gets the states of all the current replacement mods.
+    std::vector<Mod::State> getReplacementStates() const;
 
     const bool hasNewSecretReplacementInfo() const {
       return m_bSecretReplacementsUpdated;

src/dxvk/rtx_render/rtx_game_capturer.cpp

@@ -150,7 +150,7 @@ namespace dxvk {
     if (m_bTriggerCapture) {
       m_bTriggerCapture = false;
       if(isIdle()) {
-        if (RtxOptions::Get()->getEnableAnyReplacements() && m_sceneManager.areReplacementsLoaded()) {
+        if (RtxOptions::Get()->getEnableAnyReplacements() && m_sceneManager.areAllReplacementsLoaded()) {
           Logger::warn("[GameCapturer] Cannot begin capture when replacement assets are enabled/loaded.");
         } else if (m_state.has<State::Capturing>()) {
           Logger::warn("[GameCapturer] Cannot begin new capture, one currently in progress.");

src/dxvk/rtx_render/rtx_mod_manager.h

@@ -27,6 +27,7 @@
 #include <string>
 #include <filesystem>
 #include <set>
+#include <cassert>
 
 namespace dxvk {
 
@@ -43,11 +44,27 @@ class Mod {
 public:
   typedef std::filesystem::path Path;
 
-  enum State : uint32_t {
+  enum ProgressState : std::uint8_t {
+    // Set when the stage has yet to be loaded.
     Unloaded = 0,
-    Loading,
+
+    // Set during the first phase of stage loading when opening the USD file.
+    OpeningUSD,
+    // Set during the next phases of stage loading when material, mesh or light processing is currently underway.
+    // When these are set the progress count may be read from for progress information.
+    ProcessingMaterials,
+    ProcessingMeshes,
+    ProcessingLights,
+
+    // Set when the stage is completely loaded without errors.
     Loaded,
-    Error,
+  };
+
+  struct State {
+    ProgressState progressState;
+    // Note: This progress value should only be read when the stage state is LoadingMaterials, LoadingMeshes or LoadingLights, as it will
+    // be uninitialized otherwise.
+    std::uint32_t progressCount;
   };
 
   virtual ~Mod();
@@ -60,7 +77,13 @@ class Mod {
   virtual bool checkForChanges(const Rc<DxvkContext>& context) = 0;
 
   State state() const {
-    return m_state.load();
+    const auto encodedState{ m_state.load() };
+    State decodedState;
+
+    decodedState.progressState = static_cast<ProgressState>((encodedState >> 29ull) & progressStateMask);
+    decodedState.progressCount = static_cast<std::uint32_t>((encodedState >> 0ull) & progressCountMask);
+
+    return decodedState;
   }
 
   const std::string& status() const {
@@ -90,17 +113,56 @@ class Mod {
 protected:
   explicit Mod(const Path& filePath);
 
-  void setState(State state) {
-    m_state = state;
+  constexpr static std::uint32_t progressStateMask{ (1ull << 3ull) - 1ull };
+  constexpr static std::uint32_t progressCountMask{ (1ull << 29ull) - 1ull };
+
+  constexpr static std::uint32_t encodeProgressState(ProgressState progressState) {
+    return static_cast<std::uint32_t>(progressState) << 29ull;
+  }
+
+  // Sets the Mod progress state, only to be used when setting to Unloaded, OpeningUSD or Loaded. Use setStateWithProgress for other states.
+  void setState(ProgressState progressState) {
+    // Note: This set state function is only intended to be used with states that do not have progress associated with them.
+    assert(
+      progressState == ProgressState::Unloaded ||
+      progressState == ProgressState::OpeningUSD ||
+      progressState == ProgressState::Loaded
+    );
+
+    m_state = encodeProgressState(progressState);
+  }
+
+  // Sets the Mod progress state with a progress count value, only to be used when setting to ProcessingMaterials/Meshes/Lights. Use setState for other states.
+  void setStateWithCount(ProgressState progressState, std::uint32_t progressCount) {
+    // Note: This set state function is only intended to be used with states that do not have progress associated with them.
+    assert(
+      progressState == ProgressState::ProcessingMaterials ||
+      progressState == ProgressState::ProcessingMeshes ||
+      progressState == ProgressState::ProcessingLights
+    );
+    // Note: Ensure the progress count falls within the expected range. The progress count isare masked during encoding for
+    // safety as it is in theory possible for values this large to be passed in at runtime, but it likely indicates a bug as there
+    // probably should not be 500 million of any sort of asset loading.
+    assert(progressCount < (1u << 29u));
+
+    m_state =
+      encodeProgressState(progressState) |
+      (static_cast<std::uint64_t>(progressCount) & progressCountMask);
   }
 
   const Path m_filePath;
   std::string m_name;
   size_t m_priority;
 
-  std::atomic<State> m_state;
+  // Note: This uses a 32 bit atomic so that the state as well as the progress count can all be encoded into it together. This ensures all the data
+  // can be read at the same time atomically to ensure all the values are in sync without the use of mutexes. This is somewhat important as the progress
+  // count will be updated fairly rapidly depending on how fast assets load and avoiding any sort of overhead is ideal.
+  // Current encoding: [3 bit progress state] [29 bit progress count]
+  std::atomic<std::uint32_t> m_state{ encodeProgressState(ProgressState::Unloaded) };
   std::string m_status = "Unloaded";
 
+  static_assert(decltype(m_state)::is_always_lock_free, "Mod state atomic should be lock-free for performance.");
+
   std::unique_ptr<AssetReplacements> m_replacements;
 };