Store view with EventUsage, and use to filter pixel history. Refs #341

renderdoc/api/replay/data_types.h

@@ -318,6 +318,7 @@ struct EventUsage
 #ifdef __cplusplus
   EventUsage() : eventID(0), usage(eUsage_None) {}
   EventUsage(uint32_t e, ResourceUsage u) : eventID(e), usage(u) {}
+  EventUsage(uint32_t e, ResourceUsage u, ResourceId v) : eventID(e), usage(u), view(v) {}
   bool operator<(const EventUsage &o) const
   {
     if(eventID != o.eventID)
@@ -330,6 +331,7 @@ struct EventUsage
 
   uint32_t eventID;
   ResourceUsage usage;
+  ResourceId view;
 };
 
 struct FetchDrawcall

renderdoc/driver/d3d11/d3d11_analyse.cpp

@@ -5301,6 +5301,8 @@ vector<PixelModification> D3D11DebugManager::PixelHistory(vector<EventUsage> eve
     } while(hr == S_FALSE);
     RDCASSERTEQUAL(hr, S_OK);
 
+    D3D11RenderState::ResourceRange resourceRange(targetres, mip, slice);
+
     const FetchDrawcall *draw = m_WrappedDevice->GetDrawcall(events[i].eventID);
 
     bool clear = (draw->flags & eDraw_Clear);
@@ -5311,6 +5313,64 @@ vector<PixelModification> D3D11DebugManager::PixelHistory(vector<EventUsage> eve
          events[i].usage == eUsage_Resolve || events[i].usage == eUsage_ResolveDst ||
          events[i].usage == eUsage_GenMips);
 
+    if(events[i].view != ResourceId())
+    {
+      // if the access is through a view, check the mip/slice matches
+      bool used = false;
+
+      ID3D11DeviceChild *view = m_ResourceManager->GetCurrentResource(events[i].view);
+
+      if(WrappedID3D11RenderTargetView1::IsAlloc(view))
+      {
+        WrappedID3D11RenderTargetView1 *rtv = (WrappedID3D11RenderTargetView1 *)view;
+
+        D3D11RenderState::ResourceRange viewRange(rtv->GetReal());
+
+        if(viewRange.Intersects(resourceRange))
+          used = true;
+      }
+      else if(WrappedID3D11DepthStencilView::IsAlloc(view))
+      {
+        WrappedID3D11DepthStencilView *dsv = (WrappedID3D11DepthStencilView *)view;
+
+        D3D11RenderState::ResourceRange viewRange(dsv->GetReal());
+
+        if(viewRange.Intersects(resourceRange))
+          used = true;
+      }
+      else if(WrappedID3D11ShaderResourceView1::IsAlloc(view))
+      {
+        WrappedID3D11ShaderResourceView1 *srv = (WrappedID3D11ShaderResourceView1 *)view;
+
+        D3D11RenderState::ResourceRange viewRange(srv->GetReal());
+
+        if(viewRange.Intersects(resourceRange))
+          used = true;
+      }
+      else if(WrappedID3D11UnorderedAccessView1::IsAlloc(view))
+      {
+        WrappedID3D11UnorderedAccessView1 *uav = (WrappedID3D11UnorderedAccessView1 *)view;
+
+        D3D11RenderState::ResourceRange viewRange(uav->GetReal());
+
+        if(viewRange.Intersects(resourceRange))
+          used = true;
+      }
+      else
+      {
+        RDCWARN("Unexpected view type, ID %llu. Assuming used...", events[i].view);
+        used = true;
+      }
+
+      if(!used)
+      {
+        RDCDEBUG("Usage %d at %u didn't refer to the matching mip/slice (%u/%u)", events[i].usage,
+                 events[i].eventID, mip, slice);
+        occlData = 0;
+        clear = uavWrite = false;
+      }
+    }
+
     if(occlData > 0 || clear || uavWrite)
     {
       PixelModification mod;
@@ -5373,133 +5433,6 @@ vector<PixelModification> D3D11DebugManager::PixelHistory(vector<EventUsage> eve
             if(curDSV)
               curDSV->Release();
           }
-
-          // check that this selected mip/slice is the one being rendered to here
-          if(events[i].usage == eUsage_ColourTarget)
-          {
-            bool used = false;
-            for(int rtv = 0; rtv < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; rtv++)
-            {
-              if(curRTVs[rtv])
-              {
-                ID3D11Resource *res = NULL;
-                curRTVs[rtv]->GetResource(&res);
-
-                if(res != targetres)
-                  continue;
-
-                SAFE_RELEASE(res);
-
-                D3D11_RENDER_TARGET_VIEW_DESC desc;
-                curRTVs[rtv]->GetDesc(&desc);
-                if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE1D &&
-                   desc.Texture1D.MipSlice == mip)
-                {
-                  used = true;
-                  break;
-                }
-                else if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE1DARRAY &&
-                        desc.Texture1DArray.MipSlice == mip &&
-                        desc.Texture1DArray.FirstArraySlice <= slice &&
-                        desc.Texture1DArray.FirstArraySlice + desc.Texture1DArray.ArraySize > slice)
-                {
-                  used = true;
-                  break;
-                }
-                else if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE2D &&
-                        desc.Texture2D.MipSlice == mip)
-                {
-                  used = true;
-                  break;
-                }
-                else if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE2DARRAY &&
-                        desc.Texture2DArray.MipSlice == mip &&
-                        desc.Texture2DArray.FirstArraySlice <= slice &&
-                        desc.Texture2DArray.FirstArraySlice + desc.Texture2DArray.ArraySize > slice)
-                {
-                  used = true;
-                  break;
-                }
-                else if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE2DMS)
-                {
-                  used = true;
-                  break;
-                }
-                else if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY &&
-                        desc.Texture2DMSArray.FirstArraySlice <= slice &&
-                        desc.Texture2DMSArray.FirstArraySlice + desc.Texture2DMSArray.ArraySize >
-                            slice)
-                {
-                  used = true;
-                  break;
-                }
-                else if(desc.ViewDimension == D3D11_RTV_DIMENSION_TEXTURE3D &&
-                        desc.Texture3D.MipSlice == mip && desc.Texture3D.FirstWSlice <= slice &&
-                        desc.Texture3D.FirstWSlice + desc.Texture3D.WSize > slice)
-                {
-                  used = true;
-                  break;
-                }
-              }
-            }
-            if(!used)
-              continue;
-          }
-          else if(events[i].usage == eUsage_DepthStencilTarget)
-          {
-            if(!curDSV)
-              continue;
-
-            ID3D11Resource *res = NULL;
-            curDSV->GetResource(&res);
-
-            if(res != targetres)
-              continue;
-
-            SAFE_RELEASE(res);
-
-            D3D11_DEPTH_STENCIL_VIEW_DESC desc;
-            curDSV->GetDesc(&desc);
-
-            bool used = false;
-
-            if(desc.ViewDimension == D3D11_DSV_DIMENSION_TEXTURE1D && desc.Texture1D.MipSlice == mip)
-            {
-              used = true;
-            }
-            else if(desc.ViewDimension == D3D11_DSV_DIMENSION_TEXTURE1DARRAY &&
-                    desc.Texture1DArray.MipSlice == mip &&
-                    desc.Texture1DArray.FirstArraySlice <= slice &&
-                    desc.Texture1DArray.FirstArraySlice + desc.Texture1DArray.ArraySize > slice)
-            {
-              used = true;
-            }
-            else if(desc.ViewDimension == D3D11_DSV_DIMENSION_TEXTURE2D &&
-                    desc.Texture2D.MipSlice == mip)
-            {
-              used = true;
-            }
-            else if(desc.ViewDimension == D3D11_DSV_DIMENSION_TEXTURE2DARRAY &&
-                    desc.Texture2DArray.MipSlice == mip &&
-                    desc.Texture2DArray.FirstArraySlice <= slice &&
-                    desc.Texture2DArray.FirstArraySlice + desc.Texture2DArray.ArraySize > slice)
-            {
-              used = true;
-            }
-            else if(desc.ViewDimension == D3D11_DSV_DIMENSION_TEXTURE2DMS)
-            {
-              used = true;
-            }
-            else if(desc.ViewDimension == D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY &&
-                    desc.Texture2DMSArray.FirstArraySlice <= slice &&
-                    desc.Texture2DMSArray.FirstArraySlice + desc.Texture2DMSArray.ArraySize > slice)
-            {
-              used = true;
-            }
-
-            if(!used)
-              continue;
-          }
         }
 
         curNumScissors = curNumViews = 16;

renderdoc/driver/d3d11/d3d11_context.cpp

@@ -843,16 +843,27 @@ void WrappedID3D11DeviceContext::AddUsage(const FetchDrawcall &d)
             EventUsage(e, (ResourceUsage)(eUsage_VS_Constants + s)));
 
     for(int i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
+    {
       if(sh.Used_SRV(i))
-        m_ResourceUses[((WrappedID3D11ShaderResourceView1 *)sh.SRVs[i])->GetResourceResID()].push_back(
-            EventUsage(e, (ResourceUsage)(eUsage_VS_Resource + s)));
+      {
+        WrappedID3D11ShaderResourceView1 *view = (WrappedID3D11ShaderResourceView1 *)sh.SRVs[i];
+        m_ResourceUses[view->GetResourceResID()].push_back(
+            EventUsage(e, (ResourceUsage)(eUsage_VS_Resource + s), view->GetResourceID()));
+      }
+    }
 
     if(s == 5)
     {
       for(int i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+      {
         if(pipe->CS.Used_UAV(i) && pipe->CSUAVs[i])
-          m_ResourceUses[((WrappedID3D11UnorderedAccessView1 *)pipe->CSUAVs[i])->GetResourceResID()]
-              .push_back(EventUsage(e, eUsage_CS_RWResource));
+        {
+          WrappedID3D11UnorderedAccessView1 *view =
+              (WrappedID3D11UnorderedAccessView1 *)pipe->CSUAVs[i];
+          m_ResourceUses[view->GetResourceResID()].push_back(
+              EventUsage(e, eUsage_CS_RWResource, view->GetResourceID()));
+        }
+      }
     }
   }
 
@@ -867,18 +878,32 @@ void WrappedID3D11DeviceContext::AddUsage(const FetchDrawcall &d)
   // OM
 
   for(int i = 0; i < D3D11_1_UAV_SLOT_COUNT; i++)
+  {
     if(pipe->PS.Used_UAV(i) && pipe->OM.UAVs[i])
-      m_ResourceUses[((WrappedID3D11UnorderedAccessView1 *)pipe->OM.UAVs[i])->GetResourceResID()]
-          .push_back(EventUsage(e, eUsage_PS_RWResource));
+    {
+      WrappedID3D11UnorderedAccessView1 *view = (WrappedID3D11UnorderedAccessView1 *)pipe->OM.UAVs[i];
+      m_ResourceUses[view->GetResourceResID()].push_back(
+          EventUsage(e, eUsage_PS_RWResource, view->GetResourceID()));
+    }
+  }
 
   if(pipe->OM.DepthView)    // assuming for now that any DSV bound is used.
-    m_ResourceUses[((WrappedID3D11DepthStencilView *)pipe->OM.DepthView)->GetResourceResID()].push_back(
-        EventUsage(e, eUsage_DepthStencilTarget));
+  {
+    WrappedID3D11DepthStencilView *view = (WrappedID3D11DepthStencilView *)pipe->OM.DepthView;
+    m_ResourceUses[view->GetResourceResID()].push_back(
+        EventUsage(e, eUsage_DepthStencilTarget, view->GetResourceID()));
+  }
 
   for(int i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
+  {
     if(pipe->OM.RenderTargets[i])    // assuming for now that any RTV bound is used.
-      m_ResourceUses[((WrappedID3D11RenderTargetView1 *)pipe->OM.RenderTargets[i])->GetResourceResID()]
-          .push_back(EventUsage(e, eUsage_ColourTarget));
+    {
+      WrappedID3D11RenderTargetView1 *view =
+          (WrappedID3D11RenderTargetView1 *)pipe->OM.RenderTargets[i];
+      m_ResourceUses[view->GetResourceResID()].push_back(
+          EventUsage(e, eUsage_ColourTarget, view->GetResourceID()));
+    }
+  }
 }
 
 void WrappedID3D11DeviceContext::RefreshDrawcallIDs(DrawcallTreeNode &node)

renderdoc/driver/d3d11/d3d11_context1_wrap.cpp

@@ -1672,17 +1672,29 @@ bool WrappedID3D11DeviceContext::Serialise_DiscardView(ID3D11View *pResourceView
       ID3D11DeviceChild *pLiveView = m_pDevice->GetResourceManager()->GetLiveResource(View);
 
       if(WrappedID3D11RenderTargetView1::IsAlloc(pLiveView))
-        m_ResourceUses[((WrappedID3D11RenderTargetView1 *)pLiveView)->GetResourceResID()].push_back(
-            EventUsage(m_CurEventID, eUsage_Clear));
+      {
+        WrappedID3D11RenderTargetView1 *view = (WrappedID3D11RenderTargetView1 *)pLiveView;
+        m_ResourceUses[view->GetResourceResID()].push_back(
+            EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+      }
       else if(WrappedID3D11DepthStencilView::IsAlloc(pLiveView))
-        m_ResourceUses[((WrappedID3D11DepthStencilView *)pLiveView)->GetResourceResID()].push_back(
-            EventUsage(m_CurEventID, eUsage_Clear));
+      {
+        WrappedID3D11DepthStencilView *view = (WrappedID3D11DepthStencilView *)pLiveView;
+        m_ResourceUses[view->GetResourceResID()].push_back(
+            EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+      }
       else if(WrappedID3D11ShaderResourceView1::IsAlloc(pLiveView))
-        m_ResourceUses[((WrappedID3D11ShaderResourceView1 *)pLiveView)->GetResourceResID()].push_back(
-            EventUsage(m_CurEventID, eUsage_Clear));
+      {
+        WrappedID3D11ShaderResourceView1 *view = (WrappedID3D11ShaderResourceView1 *)pLiveView;
+        m_ResourceUses[view->GetResourceResID()].push_back(
+            EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+      }
       else if(WrappedID3D11UnorderedAccessView1::IsAlloc(pLiveView))
-        m_ResourceUses[((WrappedID3D11UnorderedAccessView1 *)pLiveView)->GetResourceResID()].push_back(
-            EventUsage(m_CurEventID, eUsage_Clear));
+      {
+        WrappedID3D11UnorderedAccessView1 *view = (WrappedID3D11UnorderedAccessView1 *)pLiveView;
+        m_ResourceUses[view->GetResourceResID()].push_back(
+            EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+      }
     }
   }
 

renderdoc/driver/d3d11/d3d11_context_wrap.cpp

@@ -6110,10 +6110,11 @@ bool WrappedID3D11DeviceContext::Serialise_GenerateMips(ID3D11ShaderResourceView
 
     if(m_pDevice->GetResourceManager()->HasLiveResource(ShaderResourceView))
     {
-      id = ((WrappedID3D11ShaderResourceView1 *)m_pDevice->GetResourceManager()->GetLiveResource(
-                ShaderResourceView))
-               ->GetResourceResID();
-      m_ResourceUses[id].push_back(EventUsage(m_CurEventID, eUsage_GenMips));
+      WrappedID3D11ShaderResourceView1 *view =
+          (WrappedID3D11ShaderResourceView1 *)m_pDevice->GetResourceManager()->GetLiveResource(
+              ShaderResourceView);
+      id = view->GetResourceResID();
+      m_ResourceUses[id].push_back(EventUsage(m_CurEventID, eUsage_GenMips, view->GetResourceID()));
       id = m_pDevice->GetResourceManager()->GetOriginalID(id);
     }
 
@@ -6130,12 +6131,6 @@ bool WrappedID3D11DeviceContext::Serialise_GenerateMips(ID3D11ShaderResourceView
     draw.flags |= eDraw_GenMips;
 
     AddDrawcall(draw, true);
-
-    if(m_pDevice->GetResourceManager()->HasLiveResource(ShaderResourceView))
-      m_ResourceUses[((WrappedID3D11ShaderResourceView1 *)m_pDevice->GetResourceManager()
-                          ->GetLiveResource(ShaderResourceView))
-                         ->GetResourceResID()]
-          .push_back(EventUsage(m_CurEventID, eUsage_GenMips));
   }
 
   return true;
@@ -6298,10 +6293,12 @@ bool WrappedID3D11DeviceContext::Serialise_ClearRenderTargetView(
     AddDrawcall(draw, true);
 
     if(m_pDevice->GetResourceManager()->HasLiveResource(View))
-      m_ResourceUses[((WrappedID3D11RenderTargetView1 *)m_pDevice->GetResourceManager()->GetLiveResource(
-                          View))
-                         ->GetResourceResID()]
-          .push_back(EventUsage(m_CurEventID, eUsage_Clear));
+    {
+      WrappedID3D11RenderTargetView1 *view =
+          (WrappedID3D11RenderTargetView1 *)m_pDevice->GetResourceManager()->GetLiveResource(View);
+      m_ResourceUses[view->GetResourceResID()].push_back(
+          EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+    }
   }
 
   return true;
@@ -6474,10 +6471,12 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewUint(
     AddDrawcall(draw, true);
 
     if(m_pDevice->GetResourceManager()->HasLiveResource(View))
-      m_ResourceUses[((WrappedID3D11UnorderedAccessView1 *)m_pDevice->GetResourceManager()
-                          ->GetLiveResource(View))
-                         ->GetResourceResID()]
-          .push_back(EventUsage(m_CurEventID, eUsage_Clear));
+    {
+      WrappedID3D11UnorderedAccessView1 *view =
+          (WrappedID3D11UnorderedAccessView1 *)m_pDevice->GetResourceManager()->GetLiveResource(View);
+      m_ResourceUses[view->GetResourceResID()].push_back(
+          EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+    }
   }
 
   return true;
@@ -6640,10 +6639,12 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewFloat(
     AddDrawcall(draw, true);
 
     if(m_pDevice->GetResourceManager()->HasLiveResource(View))
-      m_ResourceUses[((WrappedID3D11UnorderedAccessView1 *)m_pDevice->GetResourceManager()
-                          ->GetLiveResource(View))
-                         ->GetResourceResID()]
-          .push_back(EventUsage(m_CurEventID, eUsage_Clear));
+    {
+      WrappedID3D11UnorderedAccessView1 *view =
+          (WrappedID3D11UnorderedAccessView1 *)m_pDevice->GetResourceManager()->GetLiveResource(View);
+      m_ResourceUses[view->GetResourceResID()].push_back(
+          EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+    }
   }
 
   return true;
@@ -6792,9 +6793,12 @@ bool WrappedID3D11DeviceContext::Serialise_ClearDepthStencilView(
     AddDrawcall(draw, true);
 
     if(m_pDevice->GetResourceManager()->HasLiveResource(View))
-      m_ResourceUses[((WrappedID3D11DepthStencilView *)m_pDevice->GetResourceManager()->GetLiveResource(View))
-                         ->GetResourceResID()]
-          .push_back(EventUsage(m_CurEventID, eUsage_Clear));
+    {
+      WrappedID3D11DepthStencilView *view =
+          (WrappedID3D11DepthStencilView *)m_pDevice->GetResourceManager()->GetLiveResource(View);
+      m_ResourceUses[view->GetResourceResID()].push_back(
+          EventUsage(m_CurEventID, eUsage_Clear, view->GetResourceID()));
+    }
   }
 
   return true;

renderdoc/driver/d3d11/d3d11_renderstate.h

@@ -74,30 +74,24 @@ struct D3D11RenderState
       fullRange = true;
     }
 
+    // construct a range for a specific mip/slice. Used for easily checking if
+    // a view includes this mip/slice
+    ResourceRange(ID3D11Resource *res, UINT mip, UINT slice)
+    {
+      resource = res;
+      minMip = mip;
+      maxMip = mip;
+      minSlice = slice;
+      maxSlice = slice;
+      fullRange = false;
+    }
+
     // initialises the range with the contents of the view
     ResourceRange(ID3D11ShaderResourceView *srv);
     ResourceRange(ID3D11UnorderedAccessView *uav);
     ResourceRange(ID3D11RenderTargetView *rtv);
     ResourceRange(ID3D11DepthStencilView *dsv);
 
-    void SetMaxes(UINT numMips, UINT numSlices)
-    {
-      if(numMips == ~0U)
-        maxMip = ~0U;
-      else
-        maxMip = minMip + numMips - 1;
-
-      if(numSlices == ~0U)
-        maxSlice = ~0U;
-      else
-        maxSlice = minSlice + numSlices - 1;
-
-      // save this bool for faster intersection tests. Note that full range could also
-      // be true if maxMip == 12 or something, but since this is just a conservative
-      // early out we are only concerned with a common case.
-      fullRange = (minMip == 0 && minSlice == 0 && maxMip == ~0U && maxSlice == ~0U);
-    }
-
     bool Intersects(const ResourceRange &range) const
     {
       if(resource != range.resource)
@@ -125,6 +119,24 @@ struct D3D11RenderState
   private:
     ResourceRange();
 
+    void SetMaxes(UINT numMips, UINT numSlices)
+    {
+      if(numMips == ~0U)
+        maxMip = ~0U;
+      else
+        maxMip = minMip + numMips - 1;
+
+      if(numSlices == ~0U)
+        maxSlice = ~0U;
+      else
+        maxSlice = minSlice + numSlices - 1;
+
+      // save this bool for faster intersection tests. Note that full range could also
+      // be true if maxMip == 12 or something, but since this is just a conservative
+      // early out we are only concerned with a common case.
+      fullRange = (minMip == 0 && minSlice == 0 && maxMip == ~0U && maxSlice == ~0U);
+    }
+
     IUnknown *resource;
     UINT minMip;
     UINT minSlice;

renderdoc/driver/vulkan/vk_core.cpp

@@ -2723,22 +2723,25 @@ void WrappedVulkan::AddUsage(VulkanDrawcallTreeNode &drawNode, vector<DebugMessa
     for(size_t i = 0; i < rp.subpasses[state.subpass].inputAttachments.size(); i++)
     {
       uint32_t att = rp.subpasses[state.subpass].inputAttachments[i];
-      drawNode.resourceUsage.push_back(std::make_pair(c.m_ImageView[fb.attachments[att].view].image,
-                                                      EventUsage(e, eUsage_InputTarget)));
+      drawNode.resourceUsage.push_back(
+          std::make_pair(c.m_ImageView[fb.attachments[att].view].image,
+                         EventUsage(e, eUsage_InputTarget, fb.attachments[att].view)));
     }
 
     for(size_t i = 0; i < rp.subpasses[state.subpass].colorAttachments.size(); i++)
     {
       uint32_t att = rp.subpasses[state.subpass].colorAttachments[i];
-      drawNode.resourceUsage.push_back(std::make_pair(c.m_ImageView[fb.attachments[att].view].image,
-                                                      EventUsage(e, eUsage_ColourTarget)));
+      drawNode.resourceUsage.push_back(
+          std::make_pair(c.m_ImageView[fb.attachments[att].view].image,
+                         EventUsage(e, eUsage_ColourTarget, fb.attachments[att].view)));
     }
 
     if(rp.subpasses[state.subpass].depthstencilAttachment >= 0)
     {
       int32_t att = rp.subpasses[state.subpass].depthstencilAttachment;
-      drawNode.resourceUsage.push_back(std::make_pair(c.m_ImageView[fb.attachments[att].view].image,
-                                                      EventUsage(e, eUsage_DepthStencilTarget)));
+      drawNode.resourceUsage.push_back(
+          std::make_pair(c.m_ImageView[fb.attachments[att].view].image,
+                         EventUsage(e, eUsage_DepthStencilTarget, fb.attachments[att].view)));
     }
   }
 }

renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp

@@ -1830,18 +1830,18 @@ bool WrappedVulkan::Serialise_vkCmdClearAttachments(Serialiser *localSerialiser,
         for(size_t i = 0; i < rp.subpasses[state.subpass].colorAttachments.size(); i++)
         {
           uint32_t att = rp.subpasses[state.subpass].colorAttachments[i];
-          drawNode.resourceUsage.push_back(
-              std::make_pair(m_CreationInfo.m_ImageView[fb.attachments[att].view].image,
-                             EventUsage(drawNode.draw.eventID, eUsage_Clear)));
+          drawNode.resourceUsage.push_back(std::make_pair(
+              m_CreationInfo.m_ImageView[fb.attachments[att].view].image,
+              EventUsage(drawNode.draw.eventID, eUsage_Clear, fb.attachments[att].view)));
         }
 
         if(draw.flags & eDraw_ClearDepthStencil &&
            rp.subpasses[state.subpass].depthstencilAttachment >= 0)
         {
           int32_t att = rp.subpasses[state.subpass].depthstencilAttachment;
-          drawNode.resourceUsage.push_back(
-              std::make_pair(m_CreationInfo.m_ImageView[fb.attachments[att].view].image,
-                             EventUsage(drawNode.draw.eventID, eUsage_Clear)));
+          drawNode.resourceUsage.push_back(std::make_pair(
+              m_CreationInfo.m_ImageView[fb.attachments[att].view].image,
+              EventUsage(drawNode.draw.eventID, eUsage_Clear, fb.attachments[att].view)));
         }
       }
     }

renderdocui/Interop/FetchInfo.cs

@@ -543,6 +543,7 @@ namespace renderdoc
     {
         public UInt32 eventID;
         public ResourceUsage usage;
+        public ResourceId view;
     };
 
     [StructLayout(LayoutKind.Sequential)]