Add acceleration structure as a virtual resource

* Add Resource_AccelerationStructure as a new resource type
* Add D3D12AccelerationStructure class for virtual resource for tracking
  acceleration structure lifetime.
* Since D3D12 doesn't provide a proper API-tracked way of seeing these
  resources, we instead will track it ourselves and create a virtual
  resource where valid ASs exist.

renderdoc/driver/d3d12/d3d12_device_rescreate_wrap.cpp

@@ -271,7 +271,15 @@ bool WrappedID3D12Device::Serialise_CreateResource(
   if(desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
   {
     type = ResourceType::Buffer;
-    prefix = "Buffer";
+    if(InitialLayout.ToStates() == D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE)
+    {
+      prefix = "Acceleration Structure";
+      ((WrappedID3D12Resource *)ret)->MarkAsAccelerationStructureResource();
+    }
+    else
+    {
+      prefix = "Buffer";
+    }
   }
   else if(desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE1D)
   {
@@ -529,8 +537,16 @@ HRESULT WrappedID3D12Device::CreateResource(
     record->Length = 0;
     wrapped->SetResourceRecord(record);
 
-    record->m_MapsCount = NumSubresources;
-    record->m_Maps = new D3D12ResourceRecord::MapData[record->m_MapsCount];
+    if(desc0.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
+       InitialLayout.ToStates() == D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE)
+    {
+      wrapped->MarkAsAccelerationStructureResource();
+    }
+    else
+    {
+      record->m_MapsCount = NumSubresources;
+      record->m_Maps = new D3D12ResourceRecord::MapData[record->m_MapsCount];
+    }
 
     if(chunkType == D3D12Chunk::Device_CreateReservedResource ||
        chunkType == D3D12Chunk::Device_CreateReservedResource1 ||

renderdoc/driver/d3d12/d3d12_initstate.cpp

@@ -70,6 +70,13 @@ bool D3D12ResourceManager::Prepare_InitialState(ID3D12DeviceChild *res)
 
     if(desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
     {
+      if(r->IsAccelerationStructureResource())
+      {
+        initContents = D3D12InitialContents(D3D12InitialContents::AccelerationStructure, r);
+        SetInitialContents(GetResID(r), initContents);
+        return true;
+      }
+
       D3D12_HEAP_PROPERTIES heapProps = {};
 
       if(sparseTable == NULL)
@@ -395,6 +402,11 @@ uint64_t D3D12ResourceManager::GetSize_InitialState(ResourceId id, const D3D12In
   }
   else if(data.resourceType == Resource_Resource)
   {
+    if(data.tag == D3D12InitialContents::AccelerationStructure)
+    {
+      return WriteSerialiser::GetChunkAlignment();
+    }
+
     ID3D12Resource *buf = (ID3D12Resource *)data.resource;
 
     uint64_t ret = WriteSerialiser::GetChunkAlignment() + 64;
@@ -979,6 +991,15 @@ void D3D12ResourceManager::Create_InitialState(ResourceId id, ID3D12DeviceChild
 
     ID3D12Resource *res = ((ID3D12Resource *)live);
 
+    WrappedID3D12Resource *wrappedResource = (WrappedID3D12Resource *)res;
+
+    if(wrappedResource->IsAccelerationStructureResource())
+    {
+      SetInitialContents(id, D3D12InitialContents(D3D12InitialContents::AccelerationStructure,
+                                                  (ID3D12Resource *)NULL));
+      return;
+    }
+
     D3D12_RESOURCE_DESC resDesc = res->GetDesc();
 
     D3D12_HEAP_PROPERTIES heapProps = {};
@@ -1075,6 +1096,11 @@ void D3D12ResourceManager::Apply_InitialState(ID3D12DeviceChild *live,
   }
   else if(type == Resource_Resource)
   {
+    if(data.tag == D3D12InitialContents::AccelerationStructure)
+    {
+      return;
+    }
+
     ResourceId id = GetResID(live);
 
     if(IsActiveReplaying(m_State) && m_Device->IsReadOnlyResource(id))

renderdoc/driver/d3d12/d3d12_manager.h

@@ -50,6 +50,7 @@ enum D3D12ResourceType
   Resource_PipelineLibrary,
   Resource_ProtectedResourceSession,
   Resource_ShaderCacheSession,
+  Resource_AccelerationStructure,
   Resource_StateObject
 };
 
@@ -741,66 +742,49 @@ struct D3D12InitialContents
     MapDirect,
     // for created initial states we always have an identical resource
     ForceCopy,
+    // for handling acceleration structures
+    AccelerationStructure
   };
-  D3D12InitialContents(D3D12Descriptor *d, uint32_t n)
-      : tag(Copy),
-        resourceType(Resource_DescriptorHeap),
-        descriptors(d),
-        numDescriptors(n),
-        resource(NULL),
-        srcData(NULL),
-        dataSize(0),
-        sparseTable(NULL),
-        sparseBinds(NULL)
+  D3D12InitialContents(D3D12Descriptor *d, uint32_t n) : D3D12InitialContents()
   {
+    tag = Copy;
+    resourceType = Resource_DescriptorHeap;
+    descriptors = d;
+    numDescriptors = n;
   }
-  D3D12InitialContents(ID3D12DescriptorHeap *r)
-      : tag(Copy),
-        resourceType(Resource_DescriptorHeap),
-        descriptors(NULL),
-        numDescriptors(0),
-        resource(r),
-        srcData(NULL),
-        dataSize(0),
-        sparseTable(NULL),
-        sparseBinds(NULL)
+  D3D12InitialContents(ID3D12DescriptorHeap *r) : D3D12InitialContents()
   {
+    tag = Copy;
+    resourceType = Resource_DescriptorHeap;
+    resource = r;
   }
-  D3D12InitialContents(ID3D12Resource *r)
-      : tag(Copy),
-        resourceType(Resource_Resource),
-        descriptors(NULL),
-        numDescriptors(0),
-        resource(r),
-        srcData(NULL),
-        dataSize(0),
-        sparseTable(NULL),
-        sparseBinds(NULL)
+  D3D12InitialContents(ID3D12Resource *r) : D3D12InitialContents()
   {
+    tag = Copy;
+    resourceType = Resource_Resource;
+    resource = r;
   }
-  D3D12InitialContents(byte *data, size_t size)
-      : tag(MapDirect),
-        resourceType(Resource_Resource),
-        descriptors(NULL),
-        numDescriptors(0),
-        resource(NULL),
-        srcData(data),
-        dataSize(size),
-        sparseTable(NULL),
-        sparseBinds(NULL)
+  D3D12InitialContents(byte *data, size_t size) : D3D12InitialContents()
   {
+    tag = MapDirect;
+    resourceType = Resource_Resource;
+    srcData = data;
+    dataSize = size;
   }
-  D3D12InitialContents(Tag tg, D3D12ResourceType type)
-      : tag(tg),
-        resourceType(type),
-        descriptors(NULL),
-        numDescriptors(0),
-        resource(NULL),
-        srcData(NULL),
-        dataSize(0),
-        sparseTable(NULL),
-        sparseBinds(NULL)
+  D3D12InitialContents(Tag tg, D3D12ResourceType type) : D3D12InitialContents()
   {
+    tag = tg;
+    resourceType = type;
+  }
+  D3D12InitialContents(Tag tg, ID3D12Resource *r) : D3D12InitialContents()
+  {
+    tag = tg;
+    if(r)
+    {
+      r->AddRef();
+    }
+    resourceType = Resource_Resource;
+    resource = r;
   }
   D3D12InitialContents()
       : tag(Copy),
@@ -814,6 +798,7 @@ struct D3D12InitialContents
         sparseBinds(NULL)
   {
   }
+
   template <typename Configuration>
   void Free(ResourceManager<Configuration> *rm)
   {

renderdoc/driver/d3d12/d3d12_resources.cpp

@@ -313,6 +313,23 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12Resource::WriteToSubresource(UINT DstSubr
   return ret;
 }
 
+WRAPPED_POOL_INST(D3D12AccelerationStructure);
+
+D3D12AccelerationStructure::D3D12AccelerationStructure(
+    WrappedID3D12Device *wrappedDevice, WrappedID3D12Resource *bufferRes,
+    D3D12BufferOffset bufferOffset,
+    const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO &preBldInfo)
+    : WrappedDeviceChild12(NULL, wrappedDevice),
+      m_bufferRes(bufferRes),
+      m_bufferOffset(bufferOffset),
+      m_preBldInfo(preBldInfo)
+{
+}
+
+D3D12AccelerationStructure::~D3D12AccelerationStructure()
+{
+  Shutdown();
+}
 void WrappedID3D12Resource::RefBuffers(D3D12ResourceManager *rm)
 {
   // only buffers go into m_Addresses

renderdoc/driver/d3d12/d3d12_resources.h

@@ -937,6 +937,8 @@ class WrappedID3D12Resource
 
   WrappedID3D12Heap *m_Heap = NULL;
 
+  bool m_isAccelerationStructureResource = false;
+
 public:
   ALLOCATE_WITH_WRAPPED_POOL(WrappedID3D12Resource, false);
 
@@ -961,6 +963,9 @@ public:
     return this->GetResourceID();
   }
 
+  bool IsAccelerationStructureResource() const { return m_isAccelerationStructureResource; }
+  void MarkAsAccelerationStructureResource() { m_isAccelerationStructureResource = true; }
+
   static void RefBuffers(D3D12ResourceManager *rm);
   static void GetMappableIDs(D3D12ResourceManager *rm, const std::unordered_set<ResourceId> &refdIDs,
                              std::unordered_set<ResourceId> &mappableIDs);
@@ -1264,6 +1269,24 @@ public:
   }
 };
 
+// class to represent acceleration structure i.e. BLAS/TLAS
+class D3D12AccelerationStructure : public WrappedDeviceChild12<ID3D12DeviceChild>
+{
+public:
+  ALLOCATE_WITH_WRAPPED_POOL(D3D12AccelerationStructure);
+
+  D3D12AccelerationStructure(WrappedID3D12Device *wrappedDevice, WrappedID3D12Resource *bufferRes,
+                             D3D12BufferOffset bufferOffset,
+                             const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO &preBldInfo);
+
+  ~D3D12AccelerationStructure();
+
+private:
+  WrappedID3D12Resource *m_bufferRes;
+  D3D12BufferOffset m_bufferOffset;
+  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO m_preBldInfo;
+};
+
 #define ALL_D3D12_TYPES                             \
   D3D12_TYPE_MACRO(ID3D12CommandAllocator);         \
   D3D12_TYPE_MACRO(ID3D12CommandSignature);         \