Merge branch 'baldurk:v1.x' into v1.x

Author: anthark

renderdoc/driver/d3d12/d3d12_pixelhistory.cpp

@@ -642,16 +642,19 @@ struct D3D12PixelHistoryCallback : public D3D12ActionCallback
 
       // Copy into a buffer, but treat the footprint as the same format as the target image
       uint32_t elementSize = GetByteSize(0, 0, 0, p.copyFormat, 0);
+      // Use Offset to get to the nearest 16KB
+      UINT64 footprintOffset = (offset >> 14) << 14;
+      UINT64 offsetRemaider = offset - footprintOffset;
+      UINT dstX = (UINT)(offsetRemaider / elementSize);
 
       dst.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
       dst.pResource = m_CallbackInfo.dstBuffer;
-      dst.PlacedFootprint.Offset = 0;
-      dst.PlacedFootprint.Footprint.Width =
-          (UINT)m_CallbackInfo.dstBuffer->GetDesc().Width / elementSize;
+      dst.PlacedFootprint.Offset = footprintOffset;
+      dst.PlacedFootprint.Footprint.Width = dstX + 1;
       dst.PlacedFootprint.Footprint.Height = 1;
       dst.PlacedFootprint.Footprint.Depth = 1;
       dst.PlacedFootprint.Footprint.Format = p.copyFormat;
-      dst.PlacedFootprint.Footprint.RowPitch = (UINT)m_CallbackInfo.dstBuffer->GetDesc().Width;
+      dst.PlacedFootprint.Footprint.RowPitch = dst.PlacedFootprint.Footprint.Width * elementSize;
 
       D3D12_BOX srcBox = {};
       srcBox.left = p.x;
@@ -661,10 +664,8 @@ struct D3D12PixelHistoryCallback : public D3D12ActionCallback
       srcBox.front = 0;
       srcBox.back = 1;
 
-      // We need to apply the offset here (measured in number of elements) rather than using
-      // PlacedFootprint.Offset (measured in bytes) because the latter must be a multiple of 512
       RDCASSERT((offset % elementSize) == 0);
-      cmd->CopyTextureRegion(&dst, (UINT)(offset / elementSize), 0, 0, &src, &srcBox);
+      cmd->CopyTextureRegion(&dst, dstX, 0, 0, &src, &srcBox);
 
       std::swap(barrier.Transition.StateBefore, barrier.Transition.StateAfter);
       cmd->ResourceBarrier(1, &barrier);

renderdoc/driver/d3d12/d3d12_postvs.cpp

@@ -2206,11 +2206,13 @@ void D3D12Replay::InitPostMSBuffers(uint32_t eventId)
   ID3D12RootSignature *annotatedSig = NULL;
 
   {
-    ID3DBlob *root = m_pDevice->GetShaderCache()->MakeRootSig(modsig);
+    ID3DBlob *blob = m_pDevice->GetShaderCache()->MakeRootSig(modsig);
     HRESULT hr =
-        m_pDevice->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
+        m_pDevice->CreateRootSignature(0, blob->GetBufferPointer(), blob->GetBufferSize(),
                                        __uuidof(ID3D12RootSignature), (void **)&annotatedSig);
 
+    SAFE_RELEASE(blob);
+
     if(annotatedSig == NULL || FAILED(hr))
     {
       ret.ampout.status = ret.meshout.status = StringFormat::Fmt(

renderdoc/driver/d3d12/d3d12_shader_feedback.cpp

@@ -1336,9 +1336,12 @@ bool D3D12Replay::FetchShaderFeedback(uint32_t eventId)
 
     if(annotatedSig == NULL || FAILED(hr))
     {
+      SAFE_RELEASE(root);
       RDCERR("Couldn't create feedback modified root signature: %s", ToStr(hr).c_str());
       return false;
     }
+
+    SAFE_RELEASE(root);
   }
 
   ID3D12PipelineState *annotatedPipe = NULL;

renderdoc/driver/shaders/dxbc/dxbc_container.cpp

@@ -743,6 +743,20 @@ void DXBCContainer::ReplaceChunk(bytebuf &ByteCode, uint32_t fourcc, const byte
       return;
     }
   }
+
+  uint32_t newOffs = uint32_t(ByteCode.size() + sizeof(uint32_t));
+  ByteCode.insert(sizeof(FileHeader) + header->numChunks * sizeof(uint32_t), (byte *)&newOffs,
+                  sizeof(newOffs));
+
+  for(uint32_t chunkIdx = 0; chunkIdx < header->numChunks; chunkIdx++)
+    chunkOffsets[chunkIdx] += sizeof(uint32_t);
+
+  ByteCode.append(replacement, size);
+
+  header->numChunks++;
+  header->fileLength = (uint32_t)ByteCode.size();
+
+  HashContainer(ByteCode.data(), ByteCode.size());
 }
 
 const byte *DXBCContainer::FindChunk(const bytebuf &ByteCode, uint32_t fourcc, size_t &size)

renderdoc/driver/shaders/dxil/dxil_bytecode_editor.cpp

@@ -1818,7 +1818,6 @@ void ProgramEditor::SetNumThreads(uint32_t dim[3])
 
     if(*headerSize >= headerSizeVer2)
     {
-      cur += headerSizeVer0;
       cur += headerSizeVer1;
       memcpy(cur, dim, sizeof(uint32_t) * 3);
     }

renderdoc/driver/vulkan/vk_debug.cpp

@@ -2570,6 +2570,9 @@ void VulkanDebugManager::InitReadbackBuffer(VkDeviceSize sz)
     m_ReadbackWindow.Create(m_pDriver, dev, AlignUp(sz, (VkDeviceSize)4096), 1,
                             GPUBuffer::eGPUBufferReadback);
 
+    m_pDriver->GetResourceManager()->SetInternalResource(GetResID(m_ReadbackWindow.buf));
+    m_pDriver->GetResourceManager()->SetInternalResource(GetResID(m_ReadbackWindow.mem));
+
     RDCLOG("Allocating readback window of %llu bytes", m_ReadbackWindow.sz);
 
     VkResult vkr = ObjDisp(dev)->MapMemory(Unwrap(dev), Unwrap(m_ReadbackWindow.mem), 0,

util/test/demos/d3d12/d3d12_pixel_history.cpp

@@ -217,6 +217,14 @@ float4 main(v2f vertIn, uint primId : SV_PrimitiveID, uint sampleId : SV_SampleI
         {Vec3f(-0.7f, 0.5f, 0.33f), Vec4f(1.0f, 1.0f, 0.0f, 1.0f), Vec2f(0.0f, 1.0f)},
         {Vec3f(-0.6f, 0.3f, 0.33f), Vec4f(1.0f, 1.0f, 0.0f, 1.0f), Vec2f(0.0f, 0.0f)},
         {Vec3f(-0.8f, 0.3f, 0.33f), Vec4f(1.0f, 1.0f, 0.0f, 1.0f), Vec2f(1.0f, 0.0f)},
+        // 1000 draws of 1 triangle
+        {Vec3f(-0.7f, 0.0f, 0.33f), Vec4f(0.5f, 1.0f, 0.0f, 1.0f), Vec2f(0.0f, 1.0f)},
+        {Vec3f(-0.8f, 0.2f, 0.33f), Vec4f(0.5f, 1.0f, 0.0f, 1.0f), Vec2f(1.0f, 0.0f)},
+        {Vec3f(-0.6f, 0.2f, 0.33f), Vec4f(0.5f, 1.0f, 0.0f, 1.0f), Vec2f(0.0f, 0.0f)},
+        // 1000 instances of 1 triangle
+        {Vec3f(-0.7f, 0.6f, 0.33f), Vec4f(1.0f, 0.5f, 0.0f, 1.0f), Vec2f(0.0f, 1.0f)},
+        {Vec3f(-0.8f, 0.8f, 0.33f), Vec4f(1.0f, 0.5f, 0.0f, 1.0f), Vec2f(1.0f, 0.0f)},
+        {Vec3f(-0.6f, 0.8f, 0.33f), Vec4f(1.0f, 0.5f, 0.0f, 1.0f), Vec2f(0.0f, 0.0f)},
     };
 
     ID3D12ResourcePtr vb = MakeBuffer().Data(VBData);
@@ -608,6 +616,17 @@ float4 main(v2f vertIn, uint primId : SV_PrimitiveID, uint sampleId : SV_SampleI
         cmd->OMSetDepthBounds(0.4f, 0.6f);
         cmd->DrawInstanced(3, 1, 66, 0);
 
+        pushMarker(cmd, "Stress Test");
+        pushMarker(cmd, "Lots of Drawcalls");
+        setMarker(cmd, "1000 Draws");
+        cmd->SetPipelineState(pass.depthWritePipe);
+        for(int d = 0; d < 1000; ++d)
+          cmd->DrawInstanced(3, 1, 72, 0);
+        popMarker(cmd);
+        setMarker(cmd, "1000 Instances");
+        cmd->DrawInstanced(3, 1000, 75, 0);
+        popMarker(cmd);
+
         // Add a marker so we can easily locate this draw
         setMarker(cmd, "Test Begin");
 

util/test/tests/D3D12/D3D12_Pixel_History.py

@@ -96,6 +96,7 @@ def primary_test(self, begin_name: str):
         depth_16bit_test_eid = self.find_action("Depth 16-bit Test", begin_renderpass_eid).next.eventId
         depth_bounds_prep_eid = self.find_action("Depth Bounds Prep", begin_renderpass_eid).next.eventId
         depth_bounds_clip_eid = self.find_action("Depth Bounds Clip", begin_renderpass_eid).next.eventId
+        one_thousand_instances_action = self.find_action("1000 Instances", begin_renderpass_eid)
 
         # For pixel 110, 100, inside the red triangle with stencil value 0x55
         x, y = 110, 100
@@ -274,6 +275,28 @@ def primary_test(self, begin_name: str):
         self.check_events(events, modifs, False)
         self.check_pixel_value(tex, x, y, get_post_mod_color(modifs[-1]), sub=sub, cast=rt.typeCast)
 
+        # For pixel 60, 130 inside the light green triangle which is 1000 draws of 1 instance of 1 triangle 
+        rdtest.log.print("Testing Lots of Drawcalls")
+        self.controller.SetFrameEvent(one_thousand_instances_action.eventId, True)
+        x, y = 60, 130
+        rdtest.log.print("Testing pixel {}, {}".format(x, y))
+        modifs: List[rd.PixelModification] = self.controller.PixelHistory(tex, x, y, sub, rt.typeCast)
+        self.check_pixel_value(tex, x, y, get_post_mod_color(modifs[-1]), sub=sub, cast=rt.typeCast)
+        countEvents = 1 + 1000
+        self.check(len(modifs) == countEvents, "Expected {} events, got {}".format(countEvents, len(modifs)))
+        self.check_modifs_consistent(modifs)
+
+        # For pixel 60, 50 inside the orange triangle which is 1 draws of 1000 instances of 1 triangle 
+        rdtest.log.print("Testing Lots of Instances")
+        self.controller.SetFrameEvent(one_thousand_instances_action.next.eventId, True)
+        x, y = 60, 50
+        rdtest.log.print("Testing pixel {}, {}".format(x, y))
+        modifs: List[rd.PixelModification] = self.controller.PixelHistory(tex, x, y, sub, rt.typeCast)
+        self.check_pixel_value(tex, x, y, get_post_mod_color(modifs[-1]), sub=sub, cast=rt.typeCast)
+        countEvents = 1 + 255
+        self.check(len(modifs) == countEvents, "Expected {} events, got {}".format(countEvents, len(modifs)))
+        self.check_modifs_consistent(modifs)
+
     def multisampled_image_test(self, pass_name: str):
         begin_pass_action = self.find_action(pass_name)
         if begin_pass_action is None: