Merge branch 'dev/adunn/precision_vertex_cap' into 'main'

Significantly improve precision issues in vertex shader based games

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

Author: AlexDunn

src/d3d9/d3d9_rtx.cpp

@@ -131,11 +131,7 @@ namespace dxvk {
   void D3D9Rtx::prepareVertexCapture(const int vertexIndexOffset) {
     ScopedCpuProfileZone();
 
-    struct CapturedVertex {
-      Vector4 position;
-      Vector4 texcoord0;
-      Vector4 normal0;
-    };
+    static_assert(sizeof CapturedVertex == 48, "The injected shader code is expecting this exact structure size to work correctly, see emitVertexCaptureWrite in dxso_compiler.cpp");
 
     auto BoundShaderHas = [&](const D3D9CommonShader* shader, DxsoUsage usage, bool inOut)-> bool {
       if (shader == nullptr)
@@ -173,23 +169,28 @@ namespace dxvk {
     }
 
     // Check if we should/can get normals.  We don't see a lot of games sending normals to pixel shader, so we must capture from the IA output (or Vertex input)
-    if (BoundShaderHas(vertexShader, DxsoUsage::Normal, true) && useVertexCapturedNormals()) {
+    if ((BoundShaderHas(vertexShader, DxsoUsage::Normal, false) || BoundShaderHas(vertexShader, DxsoUsage::Normal, true)) && useVertexCapturedNormals()) {
       const uint32_t normalOffset = offsetof(CapturedVertex, normal0);
       geoData.normalBuffer = RasterBuffer(slice, normalOffset, stride, VK_FORMAT_R32G32B32_SFLOAT);
       assert(geoData.normalBuffer.offset() % 4 == 0);
     } else {
       geoData.normalBuffer = RasterBuffer();
     }
 
-    auto constants = m_vsVertexCaptureData->allocSlice();
+    // Check if we should/can get colors
+    if (BoundShaderHas(vertexShader, DxsoUsage::Color, false) && d3d9State().pixelShader.ptr() == nullptr) {
+      const uint32_t colorOffset = offsetof(CapturedVertex, color0);
+      geoData.color0Buffer = RasterBuffer(slice, colorOffset, stride, VK_FORMAT_B8G8R8A8_UNORM);
+      assert(geoData.color0Buffer.offset() % 4 == 0);
+    }
 
-    // NOTE: May be better to move reverse transformation to end of frame, because this won't work if there hasnt been a FF draw this frame to scrape the matrix from...
-    const Matrix4& ObjectToProjection = m_activeDrawCallState.transformData.viewToProjection * m_activeDrawCallState.transformData.worldToView * m_activeDrawCallState.transformData.objectToWorld;
+    auto constants = m_vsVertexCaptureData->allocSlice();
 
-    // Set constants required for vertex shader injection
-    D3D9RtxVertexCaptureData& data = *(D3D9RtxVertexCaptureData*) constants.mapPtr;
-    // Apply an inverse transform to get positions in object space (what renderer expects)
-    data.projectionToWorld = inverse(ObjectToProjection);
+    // Upload
+    auto& data = *reinterpret_cast<D3D9RtxVertexCaptureData*>(constants.mapPtr);
+    data.invProj = inverse(m_activeDrawCallState.transformData.viewToProjection);
+    data.viewToWorld = inverseAffine(m_activeDrawCallState.transformData.worldToView);
+    data.worldToObject = inverseAffine(m_activeDrawCallState.transformData.objectToWorld);
     data.normalTransform = m_activeDrawCallState.transformData.objectToWorld;
     data.baseVertex = (uint32_t)std::max(0, vertexIndexOffset);
 

src/d3d9/d3d9_state.h

@@ -31,10 +31,32 @@ namespace dxvk {
   };
 
   // NV-DXVK start: vertex shader data capture implementation
+  // NOTE: Padding exists to ensure we get vectorized loads for these attributes
+  struct CapturedVertex {
+    Vector3 position;
+    uint32_t pad0;
+    Vector2 texcoord0;
+    uint32_t pad1;
+    uint32_t pad2;
+    Vector3 normal0;
+    uint32_t color0;
+  };
+
+  enum class CapturedVertexMembers {
+    Position = 0,
+    Texcoord0,
+    Normal0,
+    Color0,
+
+    MemberCount
+  };
+
   struct D3D9RtxVertexCaptureData {
     Matrix4 normalTransform;
-    Matrix4 projectionToWorld;
     Matrix4 customWorldToProjection;
+    Matrix4 invProj;
+    Matrix4 viewToWorld;
+    Matrix4 worldToObject;
     uint32_t baseVertex = 0;
     float jitterX;
     float jitterY;
@@ -43,8 +65,10 @@ namespace dxvk {
 
   enum class D3D9RtxVertexCaptureMembers {
     NormalTransform = 0,
-    ProjectionToWorld,
     CustomWorldToProjection,
+    InvProj,
+    ViewToWorld,
+    WorldToObject,
     BaseVertex,
     JitterX,
     JitterY,