Merge branch 'underwater' into 'main'

[REMIX-2660] Support starting in translucent material based on fog state.

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

Author: MarkEHenderson

src/dxvk/imgui/dxvk_imgui.cpp

@@ -132,6 +132,9 @@ namespace dxvk {
     uint32_t textureFeatureFlags = 0;
   };
   std::unordered_map<XXH64_hash_t, ImGuiTexture> g_imguiTextureMap;
+  fast_unordered_cache<FogState> g_imguiFogMap;
+  XXH64_hash_t g_usedFogStateHash;
+  std::mutex g_imguiFogMapMutex; // protects g_imguiFogMap
 
   struct RtxTextureOption {
     const char* uniqueId;
@@ -478,6 +481,12 @@ namespace dxvk {
       g_imguiTextureMap.erase(hash);
   }
 
+  void ImGUI::SetFogStates(const fast_unordered_cache<FogState>& fogStates, XXH64_hash_t usedFogHash) {
+    const std::lock_guard<std::mutex> lock(g_imguiFogMapMutex);
+    g_imguiFogMap = fogStates;
+    g_usedFogStateHash = usedFogHash;
+  }
+
   void ImGUI::wndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
     ImGui::SetCurrentContext(m_context);
     ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam);
@@ -2264,7 +2273,6 @@ namespace dxvk {
 
           ImGui::Unindent();
         }
-
         ImGui::Unindent();
       }
 
@@ -2273,6 +2281,68 @@ namespace dxvk {
 
       showMaterialOptions();
 
+      if (ImGui::CollapsingHeader("Fog Tuning", collapsingHeaderClosedFlags)) {
+        ImGui::Indent();
+        ImGui::PushID("FogInfos");
+        if (ImGui::CollapsingHeader("Explanation", collapsingHeaderClosedFlags)) {
+          ImGui::Indent();
+          ImGui::TextWrapped("In D3D9, every draw call comes with its own fog settings."
+            " In Remix pathtracing, all rays need to use the same fog setting."
+            " So Remix will choose the earliest valid non-sky fog to use."
+
+            "\n\nIn some games, fog can be used to indicate the player is inside some "
+            "translucent medium, like being underwater.  In path tracing this is "
+            "better represented as starting inside a translucent material.  To "
+            "support this, you can copy one or more of the fog hashes listed below, "
+            "and specify a translucent replacement material in your mod.usda."
+
+            "\n\nThis replacement material should share transmittance and ior properties"
+            " with your water material, but does not need any textures set."
+
+            "\n\nReplacing a given fog state with a translucent material will disable that "
+            "fog."
+          );
+          ImGui::Unindent();
+        }
+
+        constexpr static const char* fogModes[] = {
+          "D3DFOG_NONE",
+          "D3DFOG_EXP",
+          "D3DFOG_EXP2",
+          "D3DFOG_LINEAR",
+        };
+
+        {
+          const std::lock_guard<std::mutex> lock(g_imguiFogMapMutex);
+          for (const auto& pair : g_imguiFogMap) {
+            const std::string hashString = hashToString(pair.first);
+            const char* replaced = ctx->getCommonObjects()->getSceneManager().getAssetReplacer()->getReplacementMaterial(pair.first) ? 
+              " (Replaced)" : "";
+            const char* usedAsMain = (g_usedFogStateHash == pair.first) ? " (Used for Rendering)" : "";
+            ImGui::Text("Hash: %s%s%s", hashString.c_str(), replaced, usedAsMain);
+            const FogState& fog = pair.second;
+            ImGui::Indent();
+
+            if (ImGui::Button(str::format("Copy hash to clipboard##fog_list", hashString).c_str())) {
+              ImGui::SetClipboardText(hashString.c_str());
+            }
+            if (uint32_t(fog.mode) < 4) {
+              ImGui::Text("Mode: %s", fogModes[uint32_t(fog.mode)]);
+            } else {
+              ImGui::Text("Mode: unknown enum value: %u", uint32_t(fog.mode));
+            }
+            ImGui::Text("Color: %.2f %.2f %.2f", fog.color.r, fog.color.g, fog.color.b);
+            ImGui::Text("Scale: %.2f", fog.scale);
+            ImGui::Text("End: %.2f", fog.end);
+            ImGui::Text("Density: %.2f", fog.density);
+            
+            ImGui::Unindent();
+          }
+        }
+        ImGui::PopID();
+        ImGui::Unindent();
+      }
+
       separator();
       ImGui::EndTabItem();
     }

src/dxvk/imgui/dxvk_imgui.h

@@ -96,6 +96,7 @@ namespace dxvk {
     static void AddTexture(const XXH64_hash_t hash, const Rc<DxvkImageView>& imageView, uint32_t textureFeatureFlags);
     static void ReleaseTexture(const XXH64_hash_t hash);
     static bool checkHotkeyState(const VirtualKeys& virtKeys, const bool allowContinuousPress = false);
+    static void SetFogStates(const fast_unordered_cache<FogState>& fogStates, XXH64_hash_t usedFogHash);
 
     void switchMenu(UIType type, bool force = false);
 

src/dxvk/rtx_render/rtx_context.cpp

@@ -1109,6 +1109,7 @@ namespace dxvk {
 
     constants.volumeArgs = getSceneManager().getVolumeManager().getVolumeArgs(cameraManager, 
       rtOutput.m_froxelVolumeExtent, rtOutput.m_numFroxelVolumes, getSceneManager().getFogState(), enablePortalVolumes);
+    constants.startInMediumMaterialIndex = getSceneManager().getStartInMediumMaterialIndex();
     RtxOptions::Get()->opaqueMaterialOptions.fillShaderParams(constants.opaqueMaterialArgs);
     RtxOptions::Get()->translucentMaterialOptions.fillShaderParams(constants.translucentMaterialArgs);
     RtxOptions::Get()->viewDistanceOptions.fillShaderParams(constants.viewDistanceArgs, RtxOptions::Get()->getMeterToWorldUnitScale());

src/dxvk/rtx_render/rtx_scene_manager.cpp

@@ -482,6 +482,7 @@ namespace dxvk {
     }
 
     m_activePOMCount = 0;
+    m_startInMediumMaterialIndex = BINDING_INDEX_INVALID;
 
     if (m_uniqueObjectSearchDistance != RtxOptions::uniqueObjectDistance()) {
       m_uniqueObjectSearchDistance = RtxOptions::uniqueObjectDistance();
@@ -503,8 +504,29 @@ namespace dxvk {
       return;
     }
 
-    if (m_fog.mode == D3DFOG_NONE && input.getFogState().mode != D3DFOG_NONE) {
-      m_fog = input.getFogState();
+    if (input.getFogState().mode != D3DFOG_NONE) {
+      XXH64_hash_t fogHash = input.getFogState().getHash();
+      if (m_fogStates.find(fogHash) == m_fogStates.end()) {
+        // Only do anything if we haven't seen this fog before.
+        m_fogStates[fogHash] = input.getFogState();
+
+        MaterialData* pFogReplacement = m_pReplacer->getReplacementMaterial(fogHash);
+        if (pFogReplacement) {
+          // Fog has been replaced by a translucent material to start the camera in,
+          // meaning that it was being used to indicate 'underwater' or something similar.
+          if (pFogReplacement->getType() != MaterialDataType::Translucent) {
+            Logger::warn(str::format("Fog replacement materials must be translucent.  Ignoring material for ", std::hex, m_fog.getHash()));
+          } else {
+            std::optional<RtSurfaceMaterial> surfaceMaterial {};
+
+            createSurfaceMaterial(ctx, surfaceMaterial, *pFogReplacement, input);
+            m_startInMediumMaterialIndex = m_surfaceMaterialCache.track(*surfaceMaterial);
+          }
+        } else if (m_fog.mode == D3DFOG_NONE) {
+          // render the first unreplaced fog.
+          m_fog = input.getFogState();
+        }
+      }
     }
 
     // Get Material and Mesh replacements
@@ -718,7 +740,9 @@ namespace dxvk {
   }
 
   void SceneManager::clearFogState() {
+    ImGUI::SetFogStates(m_fogStates, m_fog.getHash());
     m_fog = FogState();
+    m_fogStates.clear();
   }
 
   void SceneManager::updateBufferCache(RaytraceGeometry& newGeoData) {
@@ -879,18 +903,67 @@ namespace dxvk {
     const auto renderMaterialDataType = renderMaterialData.getType();
     std::optional<RtSurfaceMaterial> surfaceMaterial{};
 
+    createSurfaceMaterial(ctx, surfaceMaterial, renderMaterialData, drawCallState);
+
+    assert(surfaceMaterial.has_value());
+    assert(surfaceMaterial->validate());
+
+    // Cache this
+    m_surfaceMaterialCache.track(*surfaceMaterial);
+
+    RtInstance* instance = m_instanceManager.processSceneObject(m_cameraManager, m_rayPortalManager, *pBlas, drawCallState, renderMaterialData, *surfaceMaterial);
+
+    // Check if a light should be created for this Material
+    if (instance && RtxOptions::Get()->shouldConvertToLight(drawCallState.getMaterialData().getHash())) {
+      createEffectLight(ctx, drawCallState, instance);
+    }
+
+    const bool objectPickingActive = m_device->getCommon()->getResources().getRaytracingOutput()
+      .m_primaryObjectPicking.isValid();
+
+    if (objectPickingActive && instance && g_allowMappingLegacyHashToObjectPickingValue) {
+      auto meta = DrawCallMetaInfo {};
+      {
+        XXH64_hash_t h;
+        h = drawCallState.getMaterialData().getColorTexture().getImageHash();
+        if (h != kEmptyHash) {
+          meta.legacyTextureHash = h;
+        }
+        h = drawCallState.getMaterialData().getColorTexture2().getImageHash();
+        if (h != kEmptyHash) {
+          meta.legacyTextureHash2 = h;
+        }
+      }
+
+      {
+        std::lock_guard lock { m_drawCallMeta.mutex };
+        auto [iter, isNew] = m_drawCallMeta.infos[m_drawCallMeta.ticker].emplace(instance->surface.objectPickingValue, meta);
+        ONCE_IF_FALSE(isNew, Logger::warn(
+          "Found multiple draw calls with the same \'objectPickingValue\'. "
+          "Ignoring further MetaInfo-s, some objects might be not be available through object picking"));
+      }
+    }
+
+    return instance ? instance->getId() : UINT64_MAX;
+  }
+
+  void SceneManager::createSurfaceMaterial( Rc<DxvkContext> ctx, 
+                                            std::optional<RtSurfaceMaterial>& surfaceMaterial,
+                                            const MaterialData& renderMaterialData,
+                                            const DrawCallState& drawCallState) {
+    ScopedCpuProfileZone();
     const bool hasTexcoords = drawCallState.hasTextureCoordinates();
+    const auto renderMaterialDataType = renderMaterialData.getType();
 
     // We're going to use this to create a modified sampler for replacement textures.
     // Legacy and replacement materials should follow same filtering but due to lack of override capability per texture
     // legacy textures use original sampler to stay true to the original intent while replacements use more advanced filtering
     // for better quality by default.
     const Rc<DxvkSampler>& originalSampler = drawCallState.getMaterialData().getSampler(); // convenience variable for debug
     Rc<DxvkSampler> sampler = originalSampler;
-    const bool isLegacyMaterial = (renderMaterialDataType == MaterialDataType::Legacy);
     // If the original sampler if valid and the new rendering material is not legacy type
     // go ahead with patching and maybe merging the sampler states
-    if(originalSampler != nullptr && !isLegacyMaterial) {
+    if(originalSampler != nullptr && renderMaterialDataType != MaterialDataType::Legacy) {
       DxvkSamplerCreateInfo samplerInfo = originalSampler->info(); // Use sampler create info struct as convenience
       renderMaterialData.populateSamplerInfo(samplerInfo);
 
@@ -900,7 +973,7 @@ namespace dxvk {
     }
     uint32_t samplerIndex = trackSampler(sampler);
 
-    if (isLegacyMaterial || renderMaterialDataType == MaterialDataType::Opaque || drawCallState.isUsingRaytracedRenderTarget) {
+    if (renderMaterialDataType == MaterialDataType::Legacy || renderMaterialDataType == MaterialDataType::Opaque || drawCallState.isUsingRaytracedRenderTarget) {
       uint32_t albedoOpacityTextureIndex = kSurfaceMaterialInvalidTextureIndex;
       uint32_t normalTextureIndex = kSurfaceMaterialInvalidTextureIndex;
       uint32_t tangentTextureIndex = kSurfaceMaterialInvalidTextureIndex;
@@ -1109,46 +1182,6 @@ namespace dxvk {
 
       surfaceMaterial.emplace(rayPortalSurfaceMaterial);
     }
-    assert(surfaceMaterial.has_value());
-    assert(surfaceMaterial->validate());
-
-    // Cache this
-    m_surfaceMaterialCache.track(*surfaceMaterial);
-
-    RtInstance* instance = m_instanceManager.processSceneObject(m_cameraManager, m_rayPortalManager, *pBlas, drawCallState, renderMaterialData, *surfaceMaterial);
-
-    // Check if a light should be created for this Material
-    if (instance && RtxOptions::Get()->shouldConvertToLight(drawCallState.getMaterialData().getHash())) {
-      createEffectLight(ctx, drawCallState, instance);
-    }
-
-    const bool objectPickingActive = m_device->getCommon()->getResources().getRaytracingOutput()
-      .m_primaryObjectPicking.isValid();
-
-    if (objectPickingActive && instance && g_allowMappingLegacyHashToObjectPickingValue) {
-      auto meta = DrawCallMetaInfo {};
-      {
-        XXH64_hash_t h;
-        h = drawCallState.getMaterialData().getColorTexture().getImageHash();
-        if (h != kEmptyHash) {
-          meta.legacyTextureHash = h;
-        }
-        h = drawCallState.getMaterialData().getColorTexture2().getImageHash();
-        if (h != kEmptyHash) {
-          meta.legacyTextureHash2 = h;
-        }
-      }
-
-      {
-        std::lock_guard lock { m_drawCallMeta.mutex };
-        auto [iter, isNew] = m_drawCallMeta.infos[m_drawCallMeta.ticker].emplace(instance->surface.objectPickingValue, meta);
-        ONCE_IF_FALSE(isNew, Logger::warn(
-          "Found multiple draw calls with the same \'objectPickingValue\'. "
-          "Ignoring further MetaInfo-s, some objects might be not be available through object picking"));
-      }
-    }
-
-    return instance ? instance->getId() : UINT64_MAX;
   }
 
   std::optional<XXH64_hash_t> SceneManager::findLegacyTextureHashByObjectPickingValue(uint32_t objectPickingValue) {
@@ -1377,7 +1410,10 @@ namespace dxvk {
       if (m_surfaceMaterialCache.getTotalCount() > 0) {
         ScopedGpuProfileZone(ctx, "updateSurfaceMaterials");
         // Note: We duplicate the materials in the buffer so we don't have to do pointer chasing on the GPU (i.e. rather than BLAS->Surface->Material, do, BLAS->Surface, BLAS->Material)
-        const auto surfaceMaterialsGPUSize = m_accelManager.getSurfaceCount() * kSurfaceMaterialGPUSize;
+        size_t surfaceMaterialsGPUSize = m_accelManager.getSurfaceCount() * kSurfaceMaterialGPUSize;
+        if (m_startInMediumMaterialIndex != BINDING_INDEX_INVALID) {
+          surfaceMaterialsGPUSize += kSurfaceMaterialGPUSize;
+        }
 
         info.size = align(surfaceMaterialsGPUSize, kBufferAlignment);
         info.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
@@ -1394,6 +1430,13 @@ namespace dxvk {
           surfaceIndex++;
         }
 
+        if (m_startInMediumMaterialIndex != BINDING_INDEX_INVALID) {
+          auto&& surfaceMaterial = m_surfaceMaterialCache.getObjectTable()[m_startInMediumMaterialIndex];
+          surfaceMaterial.writeGPUData(surfaceMaterialsGPUData.data(), dataOffset, surfaceIndex);
+          m_startInMediumMaterialIndex = surfaceIndex;
+          surfaceIndex++;
+        }
+
         assert(dataOffset == surfaceMaterialsGPUSize);
         assert(surfaceMaterialsGPUData.size() == surfaceMaterialsGPUSize);
 

src/dxvk/rtx_render/rtx_scene_manager.h

@@ -178,7 +178,10 @@ class SceneManager : public CommonDeviceObject, public ResourceCache {
   RtCamera& getCamera() { return m_cameraManager.getMainCamera(); }
 
   FogState& getFogState() { return m_fog; }
+  const fast_unordered_cache<FogState>& getFogStates() const { return m_fogStates; }
   void clearFogState();
+
+  uint32_t getStartInMediumMaterialIndex() { return m_startInMediumMaterialIndex; }
 
   uint32_t getActivePOMCount() {return m_activePOMCount;}
 
@@ -225,6 +228,11 @@ class SceneManager : public CommonDeviceObject, public ResourceCache {
   // Consumes a draw call state and updates the scene state accordingly
   uint64_t processDrawCallState(Rc<DxvkContext> ctx, const DrawCallState& blasInput, const MaterialData* replacementMaterialData);
 
+  void createSurfaceMaterial( Rc<DxvkContext> ctx, 
+                              std::optional<RtSurfaceMaterial>& surfaceMaterial, 
+                              const MaterialData& renderMaterialData,
+                              const DrawCallState& drawCallState);
+
   // Updates ref counts for new buffers
   void updateBufferCache(RaytraceGeometry& newGeoData);
 
@@ -270,6 +278,8 @@ class SceneManager : public CommonDeviceObject, public ResourceCache {
   std::unique_ptr<TerrainBaker> m_terrainBaker;
 
   FogState m_fog;
+  fast_unordered_cache<FogState> m_fogStates;
+  uint32_t m_startInMediumMaterialIndex = BINDING_INDEX_INVALID;
 
   // TODO: Move the following resources and getters to RtResources class
   Rc<DxvkBuffer> m_surfaceMaterialBuffer;

src/dxvk/rtx_render/rtx_types.h

@@ -402,6 +402,10 @@ struct FogState {
   float scale = 0.f;
   float end = 0.f;
   float density = 0.f;
+
+  XXH64_hash_t getHash() const {
+    return XXH3_64bits(this, sizeof(FogState));
+  }
 };
 
 enum class InstanceCategories : uint32_t {