Merge branch 'NVIDIAGameWorks:main' into main

Author: Kamilkampfwagen-II

src/dxvk/imgui/dxvk_imgui_capture.cpp

@@ -54,6 +54,7 @@ namespace dxvk {
   }
 
   void ImGuiCapture::show(const Rc<DxvkContext>& ctx) {
+    auto capturer = ctx->getCommonObjects()->capturer();
     const bool disableCapture =
       ctx->getCommonObjects()->getSceneManager().areReplacementsLoaded() &&
       RtxOptions::Get()->getEnableAnyReplacements();
@@ -68,6 +69,7 @@ namespace dxvk {
         showContinuousCapture(ctx);
       }
       ImGui::Separator();
+      ImGui::Checkbox("Correct baked world transforms", &capturer->correctBakedTransformsRef());
       ImGui::Checkbox("Show menu on capture hotkey", &RtxOptions::Get()->m_captureShowMenuOnHotkey);
       if(RtxOptions::Get()->m_captureShowMenuOnHotkey) {
         ImGui::PushTextWrapPos(ImGui::GetCurrentWindow()->Size.x);

src/dxvk/meson.build

@@ -215,6 +215,7 @@ dxvk_src = files([
   'rtx_render/rtx_game_capturer.cpp',
   'rtx_render/rtx_game_capturer.h',
   'rtx_render/rtx_game_capturer_paths.h',
+  'rtx_render/rtx_game_capturer_utils.h',
   'rtx_render/rtx_geometry_utils.cpp',
   'rtx_render/rtx_geometry_utils.h',
   'rtx_render/rtx_hashing.cpp',

src/dxvk/rtx_render/rtx_game_capturer.cpp

@@ -21,6 +21,7 @@
 */
 #pragma once
 
+#include "rtx_game_capturer_utils.h"
 #include "rtx_options.h"
 
 #include "../../lssusd/game_exporter_types.h"
@@ -57,6 +58,13 @@ struct LegacyMaterialData;
 class GameCapturer : public RcObject
 {
 public:
+  RW_RTX_OPTION("rtx.capture", bool, correctBakedTransforms, false,
+                "Some games bake world transforms into mesh vertices. If individually captured\n"
+                "meshes appear to be way off in the middle of nowhere OR instanced meshes appear\n"
+                "to all have identity xform matrices, enabling will attempt to correct this and\n"
+                "improve stage + mesh viewability in tools.\n"
+                "Hashes are unaffected.");
+
   GameCapturer(DxvkDevice* const pDevice, SceneManager& sceneManager, AssetExporter& exporter);
   ~GameCapturer();
 
@@ -125,10 +133,11 @@ class GameCapturer : public RcObject
   };
 
   struct Mesh {
-    lss::Mesh    lssData;
-    size_t       instanceCount = 0;
-    XXH64_hash_t matHash;
-    MeshSync     meshSync;
+    lss::Mesh        lssData;
+    size_t           instanceCount = 0;
+    XXH64_hash_t     matHash;
+    MeshSync         meshSync;
+    AtomicOriginCalc originCalc;
   };
 
   struct Instance {
@@ -280,7 +289,8 @@ class GameCapturer : public RcObject
     std::unordered_map<XXH64_hash_t, Material> materials;
     std::unordered_map<XXH64_hash_t, Instance> instances;
     std::unordered_map<XXH64_hash_t, uint8_t> instanceFlags;
-  } m_cap;
+  };
+  std::unique_ptr<Capture> m_pCap;
 };
 
 }

src/dxvk/rtx_render/rtx_game_capturer.h

@@ -0,0 +1,110 @@
+/*
+* Copyright (c) 2023, NVIDIA CORPORATION. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sublicense,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*/
+#pragma once
+
+#include "../../lssusd/usd_include_begin.h"
+#include <pxr/base/gf/vec3f.h>
+#include "../../lssusd/usd_include_end.h"
+
+#include <atomic>
+
+namespace dxvk {
+
+struct AtomicOriginCalc; // Forward declare
+struct OriginCalc {
+  inline void compareAndSwap(const pxr::GfVec3f& vec3) {
+    replaceMin(&vec3[0]);
+    replaceMax(&vec3[0]);
+  }
+  inline void compareAndSwap(const OriginCalc& other) {
+    replaceMin(other.min);
+    replaceMax(other.max);
+  }
+  inline pxr::GfVec3f calc() const {
+    return (pxr::GfVec3f(&min[0]) + pxr::GfVec3f(&max[0])) / 2;
+  }
+private:
+  static constexpr float fMax = std::numeric_limits<float>::max();
+  float min[3] = { fMax, fMax, fMax};
+  float max[3] = {-fMax,-fMax,-fMax};
+  inline void replaceMin(const float* const vec3) {
+    min[0] = std::min(min[0],vec3[0]);
+    min[1] = std::min(min[1],vec3[1]);
+    min[2] = std::min(min[2],vec3[2]);
+  }
+  inline void replaceMax(const float* const vec3) {
+    max[0] = std::max(max[0],vec3[0]);
+    max[1] = std::max(max[1],vec3[1]);
+    max[2] = std::max(max[2],vec3[2]);
+  }
+  friend AtomicOriginCalc;
+};
+
+struct AtomicOriginCalc {
+  inline void compareAndSwap(const pxr::GfVec3f& vec3) {
+    replaceMin(&vec3[0]);
+    replaceMax(&vec3[0]);
+  }
+  inline void compareAndSwap(const OriginCalc& other) {
+    replaceMin(other.min);
+    replaceMax(other.max);
+  }
+  inline pxr::GfVec3f calc() const {
+    return (pxr::GfVec3f{min[0].load(),min[1].load(),min[2].load()} +
+            pxr::GfVec3f{max[0].load(),max[1].load(),max[2].load()})
+            / 2;
+  }
+  inline void reset() {
+    for(size_t i = 0; i < 3; ++i) {
+      min[i].store(fMax);
+      max[i].store(-fMax);
+    }
+  }
+private:
+  static constexpr float fMax = std::numeric_limits<float>::max();
+  std::atomic<float> min[3] = { fMax, fMax, fMax};
+  std::atomic<float> max[3] = {-fMax,-fMax,-fMax};
+  inline void replaceMin(const float* const vec3) {
+    swapIfLess(min[0],vec3[0]);
+    swapIfLess(min[1],vec3[1]);
+    swapIfLess(min[2],vec3[2]);
+  }
+  inline void replaceMax(const float* const vec3) {
+    swapIfGreater(max[0],vec3[0]);
+    swapIfGreater(max[1],vec3[1]);
+    swapIfGreater(max[2],vec3[2]);
+  }
+  static inline void swapIfLess(std::atomic<float>& atomic, const float other) {
+    float val = fMax;
+    do {
+      val = atomic.load();
+    } while(val > other && !atomic.compare_exchange_weak(val, other));
+  }
+  static void swapIfGreater(std::atomic<float>& atomic, const float other) {
+    float val = -fMax;
+    do {
+      val = atomic.load();
+    } while(val < other && !atomic.compare_exchange_weak(val, other));
+  }
+};
+
+}

src/dxvk/rtx_render/rtx_game_capturer_utils.h

@@ -224,6 +224,10 @@ void polymorphicSurfaceMaterialInteractionWriteToGBuffer(
         uint16_t(polymorphicSurfaceMaterialInteraction.bdata1)             // volumetricAnisotropy
       );
     }
+    else
+    {
+      subsurfaceDataTexture[position] = uint4(0, 0, 0, 0);
+    }
   }
 }