Update to latest DX headers and block workgraph functionality

2026-10-20 11:01:08 +00:00 · 2024-09-04 16:35:06 +01:00
1 parent bb6c6d84b2
commit 05ac8bed37
@@ -158,6 +158,7 @@ private:
  ID3D12GraphicsCommandList7 *m_pList7 = NULL;
  ID3D12GraphicsCommandList8 *m_pList8 = NULL;
  ID3D12GraphicsCommandList9 *m_pList9 = NULL;
+  ID3D12GraphicsCommandList10 *m_pList10 = NULL;

  RefCounter12<ID3D12GraphicsCommandList> m_RefCounter;

@@ -220,6 +221,7 @@ public:
  ID3D12GraphicsCommandList7 *GetReal7() { return m_pList7; }
  ID3D12GraphicsCommandList8 *GetReal8() { return m_pList8; }
  ID3D12GraphicsCommandList9 *GetReal9() { return m_pList9; }
+  ID3D12GraphicsCommandList10 *GetReal10() { return m_pList10; }
  WrappedID3D12Device *GetWrappedDevice() { return m_pDevice; }
  D3D12ResourceRecord *GetResourceRecord() { return m_ListRecord; }
  D3D12ResourceRecord *GetCreationRecord() { return m_CreationRecord; }
@@ -654,6 +656,14 @@ public:

  IMPLEMENT_FUNCTION_SERIALISED(virtual void STDMETHODCALLTYPE, IASetIndexBufferStripCutValue,
                                _In_ D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue);
+
+  //////////////////////////////
+  // implement ID3D12GraphicsCommandList10
+  IMPLEMENT_FUNCTION_SERIALISED(virtual void STDMETHODCALLTYPE, SetProgram,
+                                _In_ const D3D12_SET_PROGRAM_DESC *pDesc);
+
+  IMPLEMENT_FUNCTION_SERIALISED(virtual void STDMETHODCALLTYPE, DispatchGraph,
+                                _In_ const D3D12_DISPATCH_GRAPH_DESC *pDesc);
 };

 template <>
@@ -689,6 +699,8 @@ template <>
 ResourceId GetResID(ID3D12GraphicsCommandList8 *obj);
 template <>
 ResourceId GetResID(ID3D12GraphicsCommandList9 *obj);
+template <>
+ResourceId GetResID(ID3D12GraphicsCommandList10 *obj);

 ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList1 *obj);
 ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList2 *obj);
@@ -699,6 +711,7 @@ ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList6 *obj);
 ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList7 *obj);
 ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList8 *obj);
 ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList9 *obj);
+ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList10 *obj);

 ID3D12GraphicsCommandList1 *Unwrap1(ID3D12GraphicsCommandList1 *obj);
 ID3D12GraphicsCommandList2 *Unwrap2(ID3D12GraphicsCommandList2 *obj);
@@ -709,6 +722,7 @@ ID3D12GraphicsCommandList6 *Unwrap6(ID3D12GraphicsCommandList6 *obj);
 ID3D12GraphicsCommandList7 *Unwrap7(ID3D12GraphicsCommandList7 *obj);
 ID3D12GraphicsCommandList8 *Unwrap8(ID3D12GraphicsCommandList8 *obj);
 ID3D12GraphicsCommandList9 *Unwrap9(ID3D12GraphicsCommandList9 *obj);
+ID3D12GraphicsCommandList10 *Unwrap10(ID3D12GraphicsCommandList10 *obj);

 WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList1 *obj);
 WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList2 *obj);
@@ -719,3 +733,4 @@ WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList6 *obj);
 WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList7 *obj);
 WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList8 *obj);
 WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList9 *obj);
+WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList10 *obj);
@@ -0,0 +1,36 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Baldur Karlsson
+ *
+ * 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.
+ ******************************************************************************/
+
+#include "d3d12_command_list.h"
+
+void STDMETHODCALLTYPE WrappedID3D12GraphicsCommandList::SetProgram(const D3D12_SET_PROGRAM_DESC *pDesc)
+{
+  RDCERR("SetProgram called but work graphs aren't supported!");
+}
+
+void STDMETHODCALLTYPE
+WrappedID3D12GraphicsCommandList::DispatchGraph(const D3D12_DISPATCH_GRAPH_DESC *pDesc)
+{
+  RDCERR("DispatchGraph called but work graphs aren't supported!");
+}
@@ -112,6 +112,14 @@ ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList9 *obj)
  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
 }

+ID3D12GraphicsCommandList *Unwrap(ID3D12GraphicsCommandList10 *obj)
+{
+  if(obj == NULL)
+    return NULL;
+
+  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal();
+}
+
 ID3D12GraphicsCommandList1 *Unwrap1(ID3D12GraphicsCommandList1 *obj)
 {
  if(obj == NULL)
@@ -184,6 +192,14 @@ ID3D12GraphicsCommandList9 *Unwrap9(ID3D12GraphicsCommandList9 *obj)
  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal9();
 }

+ID3D12GraphicsCommandList10 *Unwrap10(ID3D12GraphicsCommandList10 *obj)
+{
+  if(obj == NULL)
+    return NULL;
+
+  return ((WrappedID3D12GraphicsCommandList *)obj)->GetReal10();
+}
+
 template <>
 ID3D12CommandList *Unwrap(ID3D12CommandList *obj)
 {
@@ -283,6 +299,15 @@ ResourceId GetResID(ID3D12GraphicsCommandList9 *obj)
  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
 }

+template <>
+ResourceId GetResID(ID3D12GraphicsCommandList10 *obj)
+{
+  if(obj == NULL)
+    return ResourceId();
+
+  return ((WrappedID3D12GraphicsCommandList *)obj)->GetResourceID();
+}
+
 template <>
 ResourceId GetResID(ID3D12CommandList *obj)
 {
@@ -382,6 +407,11 @@ WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList9 *obj)
  return ((WrappedID3D12GraphicsCommandList *)obj);
 }

+WrappedID3D12GraphicsCommandList *GetWrapped(ID3D12GraphicsCommandList10 *obj)
+{
+  return ((WrappedID3D12GraphicsCommandList *)obj);
+}
+
 ULONG STDMETHODCALLTYPE WrappedID3D12DebugCommandQueue::AddRef()
 {
  if(m_pQueue)
@@ -1006,6 +1036,10 @@ bool WrappedID3D12CommandQueue::ProcessChunk(ReadSerialiser &ser, D3D12Chunk chu
    case D3D12Chunk::Device_AddToStateObject:
    case D3D12Chunk::CreateAS:
    case D3D12Chunk::StateObject_SetPipelineStackSize:
+    case D3D12Chunk::Device_CreateHeapFromAddress1:
+    case D3D12Chunk::Device_CreateRootSignatureFromSubobjectInLibrary:
+    case D3D12Chunk::List_SetProgram:
+    case D3D12Chunk::List_DispatchGraph:
      RDCERR("Unexpected chunk while processing frame: %s", ToStr(chunk).c_str());
      return false;

@@ -1322,6 +1356,7 @@ WrappedID3D12GraphicsCommandList::WrappedID3D12GraphicsCommandList(ID3D12Graphic
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList7), (void **)&m_pList7);
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList8), (void **)&m_pList8);
    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList9), (void **)&m_pList9);
+    m_pList->QueryInterface(__uuidof(ID3D12GraphicsCommandList10), (void **)&m_pList10);
  }

  // create a temporary and grab its resource ID
@@ -1399,6 +1434,7 @@ WrappedID3D12GraphicsCommandList::~WrappedID3D12GraphicsCommandList()
  SAFE_RELEASE(m_WrappedDebug.m_pReal1);
  SAFE_RELEASE(m_WrappedDebug.m_pReal2);
  SAFE_RELEASE(m_WrappedDebug.m_pReal3);
+  SAFE_RELEASE(m_pList10);
  SAFE_RELEASE(m_pList9);
  SAFE_RELEASE(m_pList8);
  SAFE_RELEASE(m_pList7);
@@ -1634,6 +1670,19 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12GraphicsCommandList::QueryInterface(REFII
      return E_NOINTERFACE;
    }
  }
+  else if(riid == __uuidof(ID3D12GraphicsCommandList10))
+  {
+    if(m_pList10)
+    {
+      *ppvObject = (ID3D12GraphicsCommandList10 *)this;
+      AddRef();
+      return S_OK;
+    }
+    else
+    {
+      return E_NOINTERFACE;
+    }
+  }
  else if(riid == __uuidof(ID3D12CommandList))
  {
    *ppvObject = (ID3D12CommandList *)this;
@@ -35,7 +35,7 @@

 // we need to use the most-derived native interface all over the place. To make things easier when
 // new versions come out we typedef it here when we don't need the specific interface
-using ID3D12GraphicsCommandListX = ID3D12GraphicsCommandList9;
+using ID3D12GraphicsCommandListX = ID3D12GraphicsCommandList10;

 // replay only class for handling marker regions
 struct D3D12MarkerRegion
@@ -345,10 +345,11 @@ public:
  }
 };

-class WrappedID3D12DeviceConfiguration : public ID3D12DeviceConfiguration
+class WrappedID3D12DeviceConfiguration : public ID3D12DeviceConfiguration1
 {
 private:
  ID3D12DeviceConfiguration *m_pReal = NULL;
+  ID3D12DeviceConfiguration1 *m_pReal1 = NULL;
  IUnknown *wrappedParent = NULL;
 public:
  WrappedID3D12DeviceConfiguration(IUnknown *real, IUnknown *wrapped)
@@ -358,14 +359,21 @@ public:
    if(real)
    {
      HRESULT hr = real->QueryInterface(__uuidof(ID3D12DeviceConfiguration), (void **)&m_pReal);
-      if(FAILED(hr))
+      if(SUCCEEDED(hr))
+      {
+        real->QueryInterface(__uuidof(ID3D12DeviceConfiguration1), (void **)&m_pReal1);
+      }
+      else
+      {
        SAFE_RELEASE(m_pReal);
+      }
    }
  }

  ~WrappedID3D12DeviceConfiguration() { SAFE_RELEASE(m_pReal); }

  bool IsValid() { return m_pReal != NULL; }
+  bool IsValid1() { return m_pReal1 != NULL; }

  //////////////////////////////
  // Implement IUnknown
@@ -385,6 +393,12 @@ public:
      AddRef();
      return S_OK;
    }
+    if(riid == __uuidof(ID3D12DeviceConfiguration1) && m_pReal1)
+    {
+      *ppvObject = (ID3D12DeviceConfiguration1 *)this;
+      AddRef();
+      return S_OK;
+    }

    return wrappedParent->QueryInterface(riid, ppvObject);
  }
@@ -424,6 +438,17 @@ public:
  {
    return m_pReal->CreateVersionedRootSignatureDeserializer(pBlob, Size, riid, ppvDeserializer);
  }
+
+  //////////////////////////////
+  // Implement ID3D12DeviceConfiguration1
+
+  virtual HRESULT STDMETHODCALLTYPE CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary(
+      _In_reads_bytes_(Size) const void *pLibraryBlob, SIZE_T Size,
+      LPCWSTR RootSignatureSubobjectName, REFIID riid, _COM_Outptr_ void **ppvDeserializer)
+  {
+    return m_pReal1->CreateVersionedRootSignatureDeserializerFromSubobjectInLibrary(
+        pLibraryBlob, Size, RootSignatureSubobjectName, riid, ppvDeserializer);
+  }
 };

 struct D3D12RootSignatureParameter : D3D12_ROOT_PARAMETER1
@@ -593,31 +618,32 @@ struct D3D12CommandSignature
 // directly as-if it were the original type, then on replay load up the resource if available.
 // Really this is only one type of serialisation, but we declare a couple of overloads to account
 // for resources being accessed through different interfaces in different functions
-#define SERIALISE_D3D_INTERFACES()                 \
-  SERIALISE_INTERFACE(ID3D12Object);               \
-  SERIALISE_INTERFACE(ID3D12DeviceChild);          \
-  SERIALISE_INTERFACE(ID3D12Pageable);             \
-  SERIALISE_INTERFACE(ID3D12CommandList);          \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList);  \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList1); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList2); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList3); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList4); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList5); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList6); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList7); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList8); \
-  SERIALISE_INTERFACE(ID3D12GraphicsCommandList9); \
-  SERIALISE_INTERFACE(ID3D12RootSignature);        \
-  SERIALISE_INTERFACE(ID3D12Resource);             \
-  SERIALISE_INTERFACE(ID3D12QueryHeap);            \
-  SERIALISE_INTERFACE(ID3D12PipelineState);        \
-  SERIALISE_INTERFACE(ID3D12Heap);                 \
-  SERIALISE_INTERFACE(ID3D12Fence);                \
-  SERIALISE_INTERFACE(ID3D12DescriptorHeap);       \
-  SERIALISE_INTERFACE(ID3D12CommandSignature);     \
-  SERIALISE_INTERFACE(ID3D12CommandQueue);         \
-  SERIALISE_INTERFACE(ID3D12CommandAllocator);     \
+#define SERIALISE_D3D_INTERFACES()                  \
+  SERIALISE_INTERFACE(ID3D12Object);                \
+  SERIALISE_INTERFACE(ID3D12DeviceChild);           \
+  SERIALISE_INTERFACE(ID3D12Pageable);              \
+  SERIALISE_INTERFACE(ID3D12CommandList);           \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList);   \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList1);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList2);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList3);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList4);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList5);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList6);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList7);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList8);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList9);  \
+  SERIALISE_INTERFACE(ID3D12GraphicsCommandList10); \
+  SERIALISE_INTERFACE(ID3D12RootSignature);         \
+  SERIALISE_INTERFACE(ID3D12Resource);              \
+  SERIALISE_INTERFACE(ID3D12QueryHeap);             \
+  SERIALISE_INTERFACE(ID3D12PipelineState);         \
+  SERIALISE_INTERFACE(ID3D12Heap);                  \
+  SERIALISE_INTERFACE(ID3D12Fence);                 \
+  SERIALISE_INTERFACE(ID3D12DescriptorHeap);        \
+  SERIALISE_INTERFACE(ID3D12CommandSignature);      \
+  SERIALISE_INTERFACE(ID3D12CommandQueue);          \
+  SERIALISE_INTERFACE(ID3D12CommandAllocator);      \
  SERIALISE_INTERFACE(ID3D12StateObject);

 #define SERIALISE_INTERFACE(iface) DECLARE_REFLECTION_STRUCT(iface *)
@@ -1227,5 +1253,9 @@ enum class D3D12Chunk : uint32_t
  List_SetPipelineState1,
  CreateAS,
  StateObject_SetPipelineStackSize,
+  Device_CreateHeapFromAddress1,
+  Device_CreateRootSignatureFromSubobjectInLibrary,
+  List_SetProgram,
+  List_DispatchGraph,
  Max,
 };
@@ -112,7 +112,8 @@ HRESULT STDMETHODCALLTYPE DummyID3D12DebugDevice::QueryInterface(REFIID riid, vo
     riid == __uuidof(ID3D12Device5) || riid == __uuidof(ID3D12Device6) ||
     riid == __uuidof(ID3D12Device7) || riid == __uuidof(ID3D12Device8) ||
     riid == __uuidof(ID3D12Device9) || riid == __uuidof(ID3D12Device10) ||
-     riid == __uuidof(ID3D12Device11) || riid == __uuidof(ID3D12Device12))
+     riid == __uuidof(ID3D12Device11) || riid == __uuidof(ID3D12Device12) ||
+     riid == __uuidof(ID3D12Device13) || riid == __uuidof(ID3D12Device14))
    return m_pDevice->QueryInterface(riid, ppvObject);

  if(riid == __uuidof(IUnknown))
@@ -148,7 +149,8 @@ HRESULT STDMETHODCALLTYPE WrappedID3D12DebugDevice::QueryInterface(REFIID riid,
     riid == __uuidof(ID3D12Device5) || riid == __uuidof(ID3D12Device6) ||
     riid == __uuidof(ID3D12Device7) || riid == __uuidof(ID3D12Device8) ||
     riid == __uuidof(ID3D12Device9) || riid == __uuidof(ID3D12Device10) ||
-     riid == __uuidof(ID3D12Device11) || riid == __uuidof(ID3D12Device12))
+     riid == __uuidof(ID3D12Device11) || riid == __uuidof(ID3D12Device12) ||
+     riid == __uuidof(ID3D12Device13) || riid == __uuidof(ID3D12Device14))
    return m_pDevice->QueryInterface(riid, ppvObject);

  if(riid == __uuidof(IUnknown))
@@ -558,6 +560,8 @@ WrappedID3D12Device::WrappedID3D12Device(ID3D12Device *realDevice, D3D12InitPara
  m_pDevice10 = NULL;
  m_pDevice11 = NULL;
  m_pDevice12 = NULL;
+  m_pDevice13 = NULL;
+  m_pDevice14 = NULL;
  m_pDownlevel = NULL;
  if(m_pDevice)
  {
@@ -573,6 +577,8 @@ WrappedID3D12Device::WrappedID3D12Device(ID3D12Device *realDevice, D3D12InitPara
    m_pDevice->QueryInterface(__uuidof(ID3D12Device10), (void **)&m_pDevice10);
    m_pDevice->QueryInterface(__uuidof(ID3D12Device11), (void **)&m_pDevice11);
    m_pDevice->QueryInterface(__uuidof(ID3D12Device12), (void **)&m_pDevice12);
+    m_pDevice->QueryInterface(__uuidof(ID3D12Device13), (void **)&m_pDevice13);
+    m_pDevice->QueryInterface(__uuidof(ID3D12Device14), (void **)&m_pDevice14);
    m_pDevice->QueryInterface(__uuidof(ID3D12DeviceRemovedExtendedData), (void **)&m_DRED.m_pReal);
    m_pDevice->QueryInterface(__uuidof(ID3D12DeviceRemovedExtendedData1), (void **)&m_DRED.m_pReal1);
    m_pDevice->QueryInterface(__uuidof(ID3D12DeviceRemovedExtendedDataSettings),
@@ -837,6 +843,9 @@ WrappedID3D12Device::WrappedID3D12Device(ID3D12Device *realDevice, D3D12InitPara
          // message about mismatched SRV dimensions, which it seems to get wrong with the
          // dummy NULL descriptors on the texture sampling code
          D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH,
+
+          // This error has a bug, it doesn't properly count events
+          D3D12_MESSAGE_ID_PIX_EVENT_UNDERFLOW,
      };

      D3D12_INFO_QUEUE_FILTER filter = {};
@@ -928,6 +937,8 @@ WrappedID3D12Device::~WrappedID3D12Device()
  SAFE_RELEASE(m_CompatDevice.m_pReal);
  SAFE_RELEASE(m_SharingContract.m_pReal);
  SAFE_RELEASE(m_pDownlevel);
+  SAFE_RELEASE(m_pDevice14);
+  SAFE_RELEASE(m_pDevice13);
  SAFE_RELEASE(m_pDevice12);
  SAFE_RELEASE(m_pDevice11);
  SAFE_RELEASE(m_pDevice10);
@@ -1248,6 +1259,32 @@ HRESULT WrappedID3D12Device::QueryInterface(REFIID riid, void **ppvObject)
      return E_NOINTERFACE;
    }
  }
+  else if(riid == __uuidof(ID3D12Device13))
+  {
+    if(m_pDevice13)
+    {
+      AddRef();
+      *ppvObject = (ID3D12Device13 *)this;
+      return S_OK;
+    }
+    else
+    {
+      return E_NOINTERFACE;
+    }
+  }
+  else if(riid == __uuidof(ID3D12Device14))
+  {
+    if(m_pDevice14)
+    {
+      AddRef();
+      *ppvObject = (ID3D12Device14 *)this;
+      return S_OK;
+    }
+    else
+    {
+      return E_NOINTERFACE;
+    }
+  }
  else if(riid == __uuidof(ID3D12DeviceConfiguration))
  {
    if(m_DevConfig.IsValid())
@@ -1259,6 +1296,17 @@ HRESULT WrappedID3D12Device::QueryInterface(REFIID riid, void **ppvObject)

    return E_NOINTERFACE;
  }
+  else if(riid == __uuidof(ID3D12DeviceConfiguration1))
+  {
+    if(m_DevConfig.IsValid1())
+    {
+      *ppvObject = (ID3D12DeviceConfiguration1 *)&m_DevConfig;
+      AddRef();
+      return S_OK;
+    }
+
+    return E_NOINTERFACE;
+  }
  else if(riid == __uuidof(ID3D12DeviceDownlevel))
  {
    if(m_pDownlevel)
@@ -4486,6 +4534,7 @@ bool WrappedID3D12Device::ProcessChunk(ReadSerialiser &ser, D3D12Chunk context)
      return Serialise_CreatePipelineState(ser, NULL, IID(), NULL);
    // these functions are serialised as-if they are a real heap.
    case D3D12Chunk::Device_CreateHeapFromAddress:
+    case D3D12Chunk::Device_CreateHeapFromAddress1:
    case D3D12Chunk::Device_CreateHeapFromFileMapping:
      return Serialise_CreateHeap(ser, NULL, IID(), NULL);
    case D3D12Chunk::Device_OpenSharedHandle:
@@ -4532,6 +4581,8 @@ bool WrappedID3D12Device::ProcessChunk(ReadSerialiser &ser, D3D12Chunk context)
    case D3D12Chunk::CreateAS: return Serialise_CreateAS(ser, NULL, 0, {}, NULL);
    case D3D12Chunk::StateObject_SetPipelineStackSize:
      return Serialise_SetPipelineStackSize(ser, NULL, 0);
+    case D3D12Chunk::Device_CreateRootSignatureFromSubobjectInLibrary:
+      return Serialise_CreateRootSignatureFromSubobjectInLibrary(ser, 0, NULL, 0, NULL, IID(), NULL);

    // in order to get a warning if we miss a case, we explicitly handle the list/queue chunks here.
    // If we actually encounter one it's an error (we should hit CaptureBegin first and switch to
@@ -4630,6 +4681,8 @@ bool WrappedID3D12Device::ProcessChunk(ReadSerialiser &ser, D3D12Chunk context)
    case D3D12Chunk::List_EmitRaytracingAccelerationStructurePostbuildInfo:
    case D3D12Chunk::List_DispatchRays:
    case D3D12Chunk::List_SetPipelineState1:
+    case D3D12Chunk::List_SetProgram:
+    case D3D12Chunk::List_DispatchGraph:
      RDCERR("Unexpected chunk while processing initialisation: %s", ToStr(context).c_str());
      return false;

@@ -37,6 +37,16 @@
 #include "d3d12_common.h"
 #include "d3d12_manager.h"

+typedef struct D3D11_RESOURCE_FLAGS
+{
+  UINT BindFlags;
+  UINT MiscFlags;
+  UINT CPUAccessFlags;
+  UINT StructureByteStride;
+} D3D11_RESOURCE_FLAGS;
+
+#include "driver/dx/official/d3d12compatibility.h"
+
 struct IAmdExtD3DFactory;

 struct D3D12InitParams
@@ -447,55 +457,6 @@ public:
  virtual void STDMETHODCALLTYPE EndCapturableWork(_In_ REFGUID guid);
 };

-// these aren't documented, they're defined in D3D12TranslationLayer in the d3d11on12 codebase
-typedef enum D3D12_COMPATIBILITY_SHARED_FLAGS
-{
-  D3D12_COMPATIBILITY_SHARED_FLAG_NONE = 0,
-  D3D12_COMPATIBILITY_SHARED_FLAG_NON_NT_HANDLE = 0x1,
-  D3D12_COMPATIBILITY_SHARED_FLAG_KEYED_MUTEX = 0x2,
-  D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12 = 0x4
-} D3D12_COMPATIBILITY_SHARED_FLAGS;
-
-typedef enum D3D12_REFLECT_SHARED_PROPERTY
-{
-  D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS = 0,
-  D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS =
-      (D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS + 1),
-  D3D12_REFLECT_SHARED_PROPERTY_NON_NT_SHARED_HANDLE =
-      (D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS + 1)
-} D3D12_REFLECT_SHARED_PROPERTY;
-
-typedef struct D3D11_RESOURCE_FLAGS
-{
-  UINT BindFlags;
-  UINT MiscFlags;
-  UINT CPUAccessFlags;
-  UINT StructureByteStride;
-} D3D11_RESOURCE_FLAGS;
-
-MIDL_INTERFACE("8f1c0e3c-fae3-4a82-b098-bfe1708207ff")
-ID3D12CompatibilityDevice : public IUnknown
-{
-public:
-  virtual HRESULT STDMETHODCALLTYPE CreateSharedResource(
-      _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties, D3D12_HEAP_FLAGS HeapFlags,
-      _In_ const D3D12_RESOURCE_DESC *pDesc, D3D12_RESOURCE_STATES InitialResourceState,
-      _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue,
-      _In_opt_ const D3D11_RESOURCE_FLAGS *pFlags11,
-      D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
-      _In_opt_ ID3D12LifetimeTracker *pLifetimeTracker,
-      _In_opt_ ID3D12SwapChainAssistant *pOwningSwapchain, REFIID riid,
-      _COM_Outptr_opt_ void **ppResource) = 0;
-
-  virtual HRESULT STDMETHODCALLTYPE CreateSharedHeap(
-      _In_ const D3D12_HEAP_DESC *pHeapDesc, D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
-      REFIID riid, _COM_Outptr_opt_ void **ppHeap) = 0;
-
-  virtual HRESULT STDMETHODCALLTYPE ReflectSharedProperties(
-      _In_ ID3D12Object * pHeapOrResource, D3D12_REFLECT_SHARED_PROPERTY ReflectType,
-      _Out_writes_bytes_(DataSize) void *pData, UINT DataSize) = 0;
-};
-
 struct WrappedCompatibilityDevice : public ID3D12CompatibilityDevice
 {
  WrappedID3D12Device &m_pDevice;
@@ -588,7 +549,7 @@ class WrappedID3D12CommandQueue;
  template <typename SerialiserType>                         \
  bool CONCAT(Serialise_, func(SerialiserType &ser, __VA_ARGS__));

-class WrappedID3D12Device : public IFrameCapturer, public ID3DDevice, public ID3D12Device12
+class WrappedID3D12Device : public IFrameCapturer, public ID3DDevice, public ID3D12Device14
 {
 private:
  ID3D12Device *m_pDevice;
@@ -604,6 +565,8 @@ private:
  ID3D12Device10 *m_pDevice10;
  ID3D12Device11 *m_pDevice11;
  ID3D12Device12 *m_pDevice12;
+  ID3D12Device13 *m_pDevice13;
+  ID3D12Device14 *m_pDevice14;
  ID3D12DeviceDownlevel *m_pDownlevel;

  WrappedID3D12DeviceConfiguration m_DevConfig;
@@ -1089,7 +1052,8 @@ public:
       iid == __uuidof(ID3D12Device6) || iid == __uuidof(ID3D12Device7) ||
       iid == __uuidof(ID3D12Device8) || iid == __uuidof(ID3D12Device9) ||
       iid == __uuidof(ID3D12Device10) || iid == __uuidof(ID3D12Device11) ||
-       iid == __uuidof(ID3D12Device12))
+       iid == __uuidof(ID3D12Device12) || iid == __uuidof(ID3D12Device13) ||
+       iid == __uuidof(ID3D12Device14))
      return true;

    return false;
@@ -1122,6 +1086,10 @@ public:
      return (ID3D12Device11 *)this;
    else if(iid == __uuidof(ID3D12Device12))
      return (ID3D12Device12 *)this;
+    else if(iid == __uuidof(ID3D12Device13))
+      return (ID3D12Device13 *)this;
+    else if(iid == __uuidof(ID3D12Device14))
+      return (ID3D12Device14 *)this;

    RDCERR("Requested unknown device interface %s", ToStr(iid).c_str());

@@ -1231,6 +1199,18 @@ public:
      this->AddRef();
      return S_OK;
    }
+    else if(riid == __uuidof(ID3D12Device13))
+    {
+      *ppvDevice = (ID3D12Device13 *)this;
+      this->AddRef();
+      return S_OK;
+    }
+    else if(riid == __uuidof(ID3D12Device14))
+    {
+      *ppvDevice = (ID3D12Device14 *)this;
+      this->AddRef();
+      return S_OK;
+    }

    return E_NOINTERFACE;
  }
@@ -1793,4 +1773,20 @@ public:
      _In_opt_count_(numResourceDescs) const UINT32 *pNumCastableFormats,
      _In_opt_count_(numResourceDescs) const DXGI_FORMAT *const *ppCastableFormats,
      _Out_writes_opt_(numResourceDescs) D3D12_RESOURCE_ALLOCATION_INFO1 *pResourceAllocationInfo1);
+
+  //////////////////////////////
+  // implement ID3D12Device13
+
+  IMPLEMENT_FUNCTION_THREAD_SERIALISED(virtual HRESULT STDMETHODCALLTYPE,
+                                       OpenExistingHeapFromAddress1, _In_ const void *pAddress,
+                                       SIZE_T size, REFIID riid, _COM_Outptr_ void **ppvHeap);
+
+  //////////////////////////////
+  // implement ID3D12Device14
+
+  IMPLEMENT_FUNCTION_THREAD_SERIALISED(virtual HRESULT STDMETHODCALLTYPE,
+                                       CreateRootSignatureFromSubobjectInLibrary, _In_ UINT nodeMask,
+                                       _In_reads_(blobLengthInBytes) const void *pLibraryBlob,
+                                       _In_ SIZE_T blobLengthInBytes, _In_opt_ LPCWSTR subobjectName,
+                                       REFIID riid, _COM_Outptr_ void **ppvRootSignature);
 };
@@ -377,7 +377,7 @@ HRESULT WrappedID3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST
     riid != __uuidof(ID3D12GraphicsCommandList3) && riid != __uuidof(ID3D12GraphicsCommandList4) &&
     riid != __uuidof(ID3D12GraphicsCommandList5) && riid != __uuidof(ID3D12GraphicsCommandList6) &&
     riid != __uuidof(ID3D12GraphicsCommandList7) && riid != __uuidof(ID3D12GraphicsCommandList8) &&
-     riid != __uuidof(ID3D12GraphicsCommandList9))
+     riid != __uuidof(ID3D12GraphicsCommandList9) && riid != __uuidof(ID3D12GraphicsCommandList10))
    return E_NOINTERFACE;

  void *realptr = NULL;
@@ -410,6 +410,8 @@ HRESULT WrappedID3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST
    real = (ID3D12GraphicsCommandList8 *)realptr;
  else if(riid == __uuidof(ID3D12GraphicsCommandList9))
    real = (ID3D12GraphicsCommandList9 *)realptr;
+  else if(riid == __uuidof(ID3D12GraphicsCommandList10))
+    real = (ID3D12GraphicsCommandList10 *)realptr;

  if(SUCCEEDED(ret))
  {
@@ -470,6 +472,8 @@ HRESULT WrappedID3D12Device::CreateCommandList(UINT nodeMask, D3D12_COMMAND_LIST
      *ppCommandList = (ID3D12GraphicsCommandList8 *)wrapped;
    else if(riid == __uuidof(ID3D12GraphicsCommandList9))
      *ppCommandList = (ID3D12GraphicsCommandList9 *)wrapped;
+    else if(riid == __uuidof(ID3D12GraphicsCommandList10))
+      *ppCommandList = (ID3D12GraphicsCommandList10 *)wrapped;
    else if(riid == __uuidof(ID3D12CommandList))
      *ppCommandList = (ID3D12CommandList *)wrapped;
    else
@@ -1229,6 +1233,8 @@ HRESULT WrappedID3D12Device::CreateRootSignature(UINT nodeMask, const void *pBlo
      wrapped = new WrappedID3D12RootSignature(real, this);
    }

+    wrapped->sig = DecodeRootSig(pBlobWithRootSignature, blobLengthInBytes);
+
    if(IsCaptureMode(m_State))
    {
      CACHE_THREAD_SERIALISER();
@@ -1242,8 +1248,6 @@ HRESULT WrappedID3D12Device::CreateRootSignature(UINT nodeMask, const void *pBlo
      record->Length = 0;
      wrapped->SetResourceRecord(record);

-      wrapped->sig = DecodeRootSig(pBlobWithRootSignature, blobLengthInBytes);
-
      if(wrapped->sig.Flags & D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE)
        wrapped->localRootSigIdx =
            GetResourceManager()->GetRaytracingResourceAndUtilHandler()->RegisterLocalRootSig(
@@ -1289,10 +1293,6 @@ HRESULT WrappedID3D12Device::CreateRootSignature(UINT nodeMask, const void *pBlo

      record->AddChunk(scope.Get());
    }
-    else
-    {
-      wrapped->sig = DecodeRootSig(pBlobWithRootSignature, blobLengthInBytes);
-    }

    *ppvRootSignature = (ID3D12RootSignature *)wrapped;
  }
@@ -2326,13 +2326,19 @@ HRESULT WrappedID3D12Device::SetStablePowerState(BOOL Enable)
 HRESULT WrappedID3D12Device::CheckFeatureSupport(D3D12_FEATURE Feature, void *pFeatureSupportData,
                                                 UINT FeatureSupportDataSize)
 {
-  static uint64_t logged = 0;
+  static uint64_t logged[2] = {};
  bool dolog = true;
  if(uint32_t(Feature) < 64)
  {
    const uint64_t bit = 1ULL << uint32_t(Feature);
-    dolog = (logged & bit) == 0;
-    logged |= bit;
+    dolog = (logged[0] & bit) == 0;
+    logged[0] |= bit;
+  }
+  else if(uint32_t(Feature - 64) < 64)
+  {
+    const uint64_t bit = 1ULL << uint32_t(Feature - 64);
+    dolog = (logged[1] & bit) == 0;
+    logged[1] |= bit;
  }

  if(dolog)
@@ -2421,6 +2427,35 @@ HRESULT WrappedID3D12Device::CheckFeatureSupport(D3D12_FEATURE Feature, void *pF

    return S_OK;
  }
+  else if(Feature == D3D12_FEATURE_D3D12_OPTIONS20)
+  {
+    D3D12_FEATURE_DATA_D3D12_OPTIONS20 *opts =
+        (D3D12_FEATURE_DATA_D3D12_OPTIONS20 *)pFeatureSupportData;
+    if(FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS20))
+      return E_INVALIDARG;
+
+    // unknown what this does, disable it
+    opts->RecreateAtTier = D3D12_RECREATE_AT_TIER_NOT_SUPPORTED;
+
+    return S_OK;
+  }
+  else if(Feature == D3D12_FEATURE_D3D12_OPTIONS21)
+  {
+    D3D12_FEATURE_DATA_D3D12_OPTIONS21 *opts =
+        (D3D12_FEATURE_DATA_D3D12_OPTIONS21 *)pFeatureSupportData;
+    if(FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS21))
+      return E_INVALIDARG;
+
+    if(dolog)
+      RDCLOG("Forcing no EI 1.1 support");
+    opts->ExecuteIndirectTier = D3D12_EXECUTE_INDIRECT_TIER_1_0;
+
+    if(dolog)
+      RDCLOG("Forcing no work graph support");
+    opts->WorkGraphsTier = D3D12_WORK_GRAPHS_TIER_NOT_SUPPORTED;
+
+    return S_OK;
+  }

  return hr;
 }
@@ -0,0 +1,100 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Baldur Karlsson
+ *
+ * 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.
+ ******************************************************************************/
+
+#include "d3d12_device.h"
+#include "driver/dxgi/dxgi_common.h"
+#include "d3d12_command_queue.h"
+#include "d3d12_resources.h"
+
+HRESULT WrappedID3D12Device::OpenExistingHeapFromAddress1(const void *pAddress, SIZE_T size,
+                                                          REFIID riid, void **ppvHeap)
+{
+  if(ppvHeap == NULL)
+    return m_pDevice13->OpenExistingHeapFromAddress1(pAddress, size, riid, ppvHeap);
+
+  if(riid != __uuidof(ID3D12Heap))
+    return E_NOINTERFACE;
+
+  ID3D12Heap *real = NULL;
+  HRESULT ret;
+  SERIALISE_TIME_CALL(
+      ret = m_pDevice13->OpenExistingHeapFromAddress1(pAddress, size, riid, (void **)&real));
+
+  if(SUCCEEDED(ret))
+  {
+    WrappedID3D12Heap *wrapped = new WrappedID3D12Heap(real, this);
+
+    if(IsCaptureMode(m_State))
+    {
+      CACHE_THREAD_SERIALISER();
+
+      D3D12_HEAP_DESC heapDesc = wrapped->GetDesc();
+
+      // remove SHARED flags that are not allowed on real heaps
+      heapDesc.Flags &= ~(D3D12_HEAP_FLAG_SHARED | D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER);
+
+      D3D12_FEATURE_DATA_D3D12_OPTIONS opts = {};
+      if(SUCCEEDED(m_pDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS, &opts, sizeof(opts))))
+      {
+        if(opts.ResourceHeapTier == D3D12_RESOURCE_HEAP_TIER_1)
+        {
+          // tier 1 devices don't support heaps with no DENY flags, but the heap we get from here
+          // will likely have no DENY flags set. Artifically add one that should be safe for this
+          // kind of heap.
+          if((heapDesc.Flags & (D3D12_HEAP_FLAG_DENY_BUFFERS | D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES |
+                                D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES)) == 0)
+          {
+            RDCWARN(
+                "Adding DENY_RT_DS_TEXTURES|DENY_NON_RT_DS_TEXTURES to OpenExistingHeap heap for "
+                "tier 1 compatibility");
+            heapDesc.Flags |=
+                D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES | D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES;
+          }
+        }
+      }
+
+      SCOPED_SERIALISE_CHUNK(D3D12Chunk::Device_CreateHeapFromAddress1);
+      Serialise_CreateHeap(ser, &heapDesc, riid, (void **)&wrapped);
+
+      D3D12ResourceRecord *record = GetResourceManager()->AddResourceRecord(wrapped->GetResourceID());
+      record->type = Resource_Heap;
+      record->Length = 0;
+      wrapped->SetResourceRecord(record);
+
+      record->AddChunk(scope.Get());
+    }
+    else
+    {
+      GetResourceManager()->AddLiveResource(wrapped->GetResourceID(), wrapped);
+    }
+
+    *ppvHeap = (ID3D12Heap *)wrapped;
+  }
+  else
+  {
+    CheckHRESULT(ret);
+  }
+
+  return ret;
+}
@@ -0,0 +1,260 @@
+/******************************************************************************
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2024 Baldur Karlsson
+ *
+ * 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.
+ ******************************************************************************/
+
+#include "d3d12_device.h"
+#include "driver/dxgi/dxgi_common.h"
+#include "driver/shaders/dxil/dxil_metadata.h"
+#include "d3d12_command_queue.h"
+#include "d3d12_resources.h"
+
+static D3D12RootSignature DecodeRootSig(const void *data, size_t dataSize, rdcstr subobjectName)
+{
+  size_t chunkSize = 0;
+  const byte *chunkData =
+      DXBC::DXBCContainer::FindChunk((const byte *)data, dataSize, DXBC::FOURCC_RDAT, chunkSize);
+
+  if(chunkSize > 0 && chunkData)
+  {
+    DXIL::RDATData rdat;
+    DXBC::DXBCContainer::GetRuntimeData(chunkData, chunkSize, rdat);
+
+    for(const DXIL::RDATData::SubobjectInfo &sub : rdat.subobjectsInfo)
+    {
+      if(sub.name == subobjectName)
+      {
+        if(sub.type == DXIL::RDATData::SubobjectInfo::SubobjectType::LocalRS ||
+           sub.type == DXIL::RDATData::SubobjectInfo::SubobjectType::GlobalRS)
+        {
+          return DecodeRootSig(sub.rs.data.data(), sub.rs.data.size(), false);
+        }
+        else
+        {
+          RDCWARN("Subobject '%s' is not a root signature", subobjectName.c_str());
+          return {};
+        }
+      }
+    }
+
+    RDCWARN("Subobject '%s' not found in library", subobjectName.c_str());
+  }
+  else
+  {
+    RDCWARN("Library blob does not contain RDAT");
+  }
+  return {};
+}
+
+template <typename SerialiserType>
+bool WrappedID3D12Device::Serialise_CreateRootSignatureFromSubobjectInLibrary(
+    SerialiserType &ser, UINT nodeMask, const void *pLibraryBlob, SIZE_T blobLengthInBytes_,
+    LPCWSTR subobjectName_, REFIID riid, void **ppvRootSignature)
+{
+  SERIALISE_ELEMENT(nodeMask);
+  SERIALISE_ELEMENT_ARRAY(pLibraryBlob, blobLengthInBytes_).Important();
+  SERIALISE_ELEMENT_LOCAL(blobLengthInBytes, uint64_t(blobLengthInBytes_));
+  SERIALISE_ELEMENT_LOCAL(subobjectName, StringFormat::Wide2UTF8(subobjectName_));
+  SERIALISE_ELEMENT_LOCAL(guid, riid).Named("riid"_lit);
+  SERIALISE_ELEMENT_LOCAL(pRootSignature,
+                          ((WrappedID3D12RootSignature *)*ppvRootSignature)->GetResourceID())
+      .TypedAs("ID3D12RootSignature *"_lit);
+
+  SERIALISE_CHECK_READ_ERRORS();
+
+  if(IsReplayingAndReading())
+  {
+    nodeMask = 0;
+
+    HRESULT hr = S_OK;
+    ID3D12RootSignature *ret = NULL;
+    if(m_pDevice14)
+    {
+      hr = m_pDevice14->CreateRootSignatureFromSubobjectInLibrary(
+          nodeMask, pLibraryBlob, (SIZE_T)blobLengthInBytes,
+          StringFormat::UTF82Wide(subobjectName).c_str(), guid, (void **)&ret);
+    }
+    else
+    {
+      SET_ERROR_RESULT(m_FailedReplayResult, ResultCode::APIHardwareUnsupported,
+                       "Capture requires ID3D12Device14 which isn't available");
+      return false;
+    }
+
+    if(FAILED(hr))
+    {
+      SET_ERROR_RESULT(m_FailedReplayResult, ResultCode::APIReplayFailed,
+                       "Failed creating root signature, HRESULT: %s", ToStr(hr).c_str());
+      return false;
+    }
+    else
+    {
+      if(GetResourceManager()->HasWrapper(ret))
+      {
+        ret->Release();
+        ret = (ID3D12RootSignature *)GetResourceManager()->GetWrapper(ret);
+        ret->AddRef();
+
+        GetResourceManager()->AddLiveResource(pRootSignature, ret);
+      }
+      else
+      {
+        ret = new WrappedID3D12RootSignature(ret, this);
+
+        GetResourceManager()->AddLiveResource(pRootSignature, ret);
+      }
+
+      WrappedID3D12RootSignature *wrapped = (WrappedID3D12RootSignature *)ret;
+
+      wrapped->sig = DecodeRootSig(pLibraryBlob, blobLengthInBytes, subobjectName);
+
+      if(wrapped->sig.Flags & D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE)
+        wrapped->localRootSigIdx =
+            GetResourceManager()->GetRaytracingResourceAndUtilHandler()->RegisterLocalRootSig(
+                wrapped->sig);
+
+      {
+        StructuredSerialiser structuriser(ser.GetStructuredFile().chunks.back(), &GetChunkName);
+        structuriser.SetUserData(GetResourceManager());
+
+        structuriser.Serialise("UnpackedSignature"_lit, wrapped->sig);
+      }
+
+      AddResource(pRootSignature, ResourceType::ShaderBinding, "Root Signature");
+    }
+  }
+
+  return true;
+}
+
+HRESULT WrappedID3D12Device::CreateRootSignatureFromSubobjectInLibrary(
+    UINT nodeMask, const void *pLibraryBlob, SIZE_T blobLengthInBytes, LPCWSTR subobjectName,
+    REFIID riid, void **ppvRootSignature)
+{
+  if(ppvRootSignature == NULL)
+    return m_pDevice14->CreateRootSignatureFromSubobjectInLibrary(
+        nodeMask, pLibraryBlob, blobLengthInBytes, subobjectName, riid, NULL);
+
+  if(riid != __uuidof(ID3D12RootSignature))
+    return E_NOINTERFACE;
+
+  ID3D12RootSignature *real = NULL;
+  HRESULT ret;
+  SERIALISE_TIME_CALL(
+      ret = m_pDevice14->CreateRootSignatureFromSubobjectInLibrary(
+          nodeMask, pLibraryBlob, blobLengthInBytes, subobjectName, riid, (void **)&real));
+
+  if(SUCCEEDED(ret))
+  {
+    WrappedID3D12RootSignature *wrapped = NULL;
+
+    {
+      SCOPED_LOCK(m_WrapDeduplicateLock);
+
+      // duplicate signatures can be returned, if Create is called with a previous equivalent blob
+      if(GetResourceManager()->HasWrapper(real))
+      {
+        real->Release();
+        ID3D12RootSignature *existing = (ID3D12RootSignature *)GetResourceManager()->GetWrapper(real);
+        existing->AddRef();
+        *ppvRootSignature = existing;
+        return ret;
+      }
+
+      wrapped = new WrappedID3D12RootSignature(real, this);
+    }
+
+    wrapped->sig =
+        DecodeRootSig(pLibraryBlob, blobLengthInBytes, StringFormat::Wide2UTF8(subobjectName));
+
+    if(IsCaptureMode(m_State))
+    {
+      CACHE_THREAD_SERIALISER();
+
+      SCOPED_SERIALISE_CHUNK(D3D12Chunk::Device_CreateRootSignatureFromSubobjectInLibrary);
+      Serialise_CreateRootSignatureFromSubobjectInLibrary(
+          ser, nodeMask, pLibraryBlob, blobLengthInBytes, subobjectName, riid, (void **)&wrapped);
+
+      D3D12ResourceRecord *record = GetResourceManager()->AddResourceRecord(wrapped->GetResourceID());
+      record->type = Resource_RootSignature;
+      record->Length = 0;
+      wrapped->SetResourceRecord(record);
+
+      if(wrapped->sig.Flags & D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE)
+        wrapped->localRootSigIdx =
+            GetResourceManager()->GetRaytracingResourceAndUtilHandler()->RegisterLocalRootSig(
+                wrapped->sig);
+
+      if(!m_BindlessResourceUseActive)
+      {
+        // force ref-all-resources if the heap is directly indexed because we can't track resource
+        // access
+        if(wrapped->sig.Flags & (D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED |
+                                 D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED))
+        {
+          m_BindlessResourceUseActive = true;
+          RDCDEBUG("Forcing Ref All Resources due to heap-indexing root signature flags");
+        }
+        else
+        {
+          for(const D3D12RootSignatureParameter &param : wrapped->sig.Parameters)
+          {
+            if(param.ParameterType != D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
+              continue;
+
+            for(UINT r = 0; r < param.DescriptorTable.NumDescriptorRanges; r++)
+            {
+              const D3D12_DESCRIPTOR_RANGE1 &range = param.DescriptorTable.pDescriptorRanges[r];
+              if(range.NumDescriptors > 100000)
+              {
+                m_BindlessResourceUseActive = true;
+                RDCDEBUG(
+                    "Forcing Ref All Resources due to large root signature range of %u descriptors "
+                    "(space=%u, reg=%u, visibility=%s)",
+                    range.NumDescriptors, range.RegisterSpace, range.BaseShaderRegister,
+                    ToStr(param.ShaderVisibility).c_str());
+                break;
+              }
+            }
+
+            if(m_BindlessResourceUseActive)
+              break;
+          }
+        }
+      }
+
+      record->AddChunk(scope.Get());
+    }
+
+    *ppvRootSignature = (ID3D12RootSignature *)wrapped;
+  }
+  else
+  {
+    CheckHRESULT(ret);
+  }
+
+  return ret;
+}
+
+INSTANTIATE_FUNCTION_SERIALISED(void, WrappedID3D12Device, CreateRootSignatureFromSubobjectInLibrary,
+                                UINT nodeMask, const void *pLibraryBlob, SIZE_T blobLengthInBytes,
+                                LPCWSTR subobjectName, REFIID riid, void **ppvRootSignature);
@@ -96,7 +96,7 @@ HRESULT WrappedID3D12Device::CreateCommandList1(UINT nodeMask, D3D12_COMMAND_LIS
     riid != __uuidof(ID3D12GraphicsCommandList3) && riid != __uuidof(ID3D12GraphicsCommandList4) &&
     riid != __uuidof(ID3D12GraphicsCommandList5) && riid != __uuidof(ID3D12GraphicsCommandList6) &&
     riid != __uuidof(ID3D12GraphicsCommandList7) && riid != __uuidof(ID3D12GraphicsCommandList8) &&
-     riid != __uuidof(ID3D12GraphicsCommandList9))
+     riid != __uuidof(ID3D12GraphicsCommandList9) && riid != __uuidof(ID3D12GraphicsCommandList10))
    return E_NOINTERFACE;

  void *realptr = NULL;
@@ -128,6 +128,8 @@ HRESULT WrappedID3D12Device::CreateCommandList1(UINT nodeMask, D3D12_COMMAND_LIS
    real = (ID3D12GraphicsCommandList8 *)realptr;
  else if(riid == __uuidof(ID3D12GraphicsCommandList9))
    real = (ID3D12GraphicsCommandList9 *)realptr;
+  else if(riid == __uuidof(ID3D12GraphicsCommandList10))
+    real = (ID3D12GraphicsCommandList10 *)realptr;

  if(SUCCEEDED(ret))
  {
@@ -183,6 +185,8 @@ HRESULT WrappedID3D12Device::CreateCommandList1(UINT nodeMask, D3D12_COMMAND_LIS
      *ppCommandList = (ID3D12GraphicsCommandList8 *)wrapped;
    else if(riid == __uuidof(ID3D12GraphicsCommandList9))
      *ppCommandList = (ID3D12GraphicsCommandList9 *)wrapped;
+    else if(riid == __uuidof(ID3D12GraphicsCommandList10))
+      *ppCommandList = (ID3D12GraphicsCommandList10 *)wrapped;
    else if(riid == __uuidof(ID3D12CommandList))
      *ppCommandList = (ID3D12CommandList *)wrapped;
    else
@@ -326,6 +326,12 @@ public:
      AddRef();
      return S_OK;
    }
+    if(riid == __uuidof(ID3D12DeviceConfiguration1) && config.IsValid1())
+    {
+      *ppvObject = (ID3D12DeviceConfiguration1 *)&config;
+      AddRef();
+      return S_OK;
+    }

    return E_NOINTERFACE;
  }
@@ -652,7 +658,8 @@ private:
       riid != __uuidof(ID3D12Device6) && riid != __uuidof(ID3D12Device7) &&
       riid != __uuidof(ID3D12Device8) && riid != __uuidof(ID3D12Device9) &&
       riid != __uuidof(ID3D12Device10) && riid != __uuidof(ID3D12Device11) &&
-       riid != __uuidof(ID3D12Device12))
+       riid != __uuidof(ID3D12Device12) && riid != __uuidof(ID3D12Device13) &&
+       riid != __uuidof(ID3D12Device14))
    {
      RDCERR("Unsupported UUID %s for D3D12CreateDevice", ToStr(riid).c_str());
      return E_NOINTERFACE;
@@ -732,18 +739,28 @@ private:
        }
        else if(riid == __uuidof(ID3D12Device10))
        {
-          ID3D12Device10 *dev9 = (ID3D12Device10 *)*ppDevice;
-          dev = (ID3D12Device *)dev9;
+          ID3D12Device10 *dev10 = (ID3D12Device10 *)*ppDevice;
+          dev = (ID3D12Device *)dev10;
        }
        else if(riid == __uuidof(ID3D12Device11))
        {
-          ID3D12Device11 *dev9 = (ID3D12Device11 *)*ppDevice;
-          dev = (ID3D12Device *)dev9;
+          ID3D12Device11 *dev11 = (ID3D12Device11 *)*ppDevice;
+          dev = (ID3D12Device *)dev11;
        }
        else if(riid == __uuidof(ID3D12Device12))
        {
-          ID3D12Device12 *dev9 = (ID3D12Device12 *)*ppDevice;
-          dev = (ID3D12Device *)dev9;
+          ID3D12Device12 *dev12 = (ID3D12Device12 *)*ppDevice;
+          dev = (ID3D12Device *)dev12;
+        }
+        else if(riid == __uuidof(ID3D12Device13))
+        {
+          ID3D12Device13 *dev13 = (ID3D12Device13 *)*ppDevice;
+          dev = (ID3D12Device *)dev13;
+        }
+        else if(riid == __uuidof(ID3D12Device14))
+        {
+          ID3D12Device14 *dev14 = (ID3D12Device14 *)*ppDevice;
+          dev = (ID3D12Device *)dev14;
        }

        WrappedID3D12Device *wrap = WrappedID3D12Device::Create(dev, params, EnableDebugLayer);
@@ -782,6 +799,10 @@ private:
          *ppDevice = (ID3D12Device11 *)wrap;
        else if(riid == __uuidof(ID3D12Device12))
          *ppDevice = (ID3D12Device12 *)wrap;
+        else if(riid == __uuidof(ID3D12Device13))
+          *ppDevice = (ID3D12Device13 *)wrap;
+        else if(riid == __uuidof(ID3D12Device14))
+          *ppDevice = (ID3D12Device14 *)wrap;
      }
    }
    else if(SUCCEEDED(ret))
@@ -1159,9 +1159,10 @@ private:
 };

 class WrappedID3D12StateObject : public WrappedDeviceChild12<ID3D12StateObject>,
-                                 public ID3D12StateObjectProperties
+                                 public ID3D12StateObjectProperties1
 {
  ID3D12StateObjectProperties *properties;
+  ID3D12StateObjectProperties1 *properties1;

 public:
  ALLOCATE_WITH_WRAPPED_POOL(WrappedID3D12StateObject);
@@ -1186,6 +1187,7 @@ public:
  {
    m_pReal = real;
    real->QueryInterface(__uuidof(ID3D12StateObjectProperties), (void **)&properties);
+    real->QueryInterface(__uuidof(ID3D12StateObjectProperties1), (void **)&properties1);
  }

  virtual ~WrappedID3D12StateObject()
@@ -1205,6 +1207,24 @@ public:
      AddRef();
      return S_OK;
    }
+    else if(riid == __uuidof(ID3D12StateObjectProperties1))
+    {
+      if(properties1)
+      {
+        *ppvObject = (ID3D12StateObjectProperties1 *)this;
+        AddRef();
+        return S_OK;
+      }
+      else
+      {
+        return E_NOINTERFACE;
+      }
+    }
+    if(riid == __uuidof(ID3D12WorkGraphProperties) || riid == __uuidof(ID3D12WorkGraphProperties1))
+    {
+      // work graphs are not currently supported
+      return E_NOINTERFACE;
+    }
    return WrappedDeviceChild12::QueryInterface(riid, ppvObject);
  }

@@ -1233,6 +1253,21 @@ public:
    m_pDevice->SetPipelineStackSize(this, PipelineStackSizeInBytes);
    properties->SetPipelineStackSize(PipelineStackSizeInBytes);
  }
+
+  //////////////////////////////
+  // implement ID3D12StateObjectProperties1
+
+#if defined(_MSC_VER) || !defined(_WIN32)
+  virtual D3D12_PROGRAM_IDENTIFIER STDMETHODCALLTYPE GetProgramIdentifier(LPCWSTR pProgramName)
+#else
+  virtual D3D12_PROGRAM_IDENTIFIER *STDMETHODCALLTYPE
+  GetProgramIdentifier(D3D12_PROGRAM_IDENTIFIER *RetVal, LPCWSTR pProgramName)
+#endif
+  {
+    if(properties1)
+      return properties1->GetProgramIdentifier(pProgramName);
+    return {};
+  }
 };

 class WrappedID3D12QueryHeap : public WrappedDeviceChild12<ID3D12QueryHeap>
@@ -28,7 +28,7 @@
 template <>
 rdcstr DoStringise(const D3D12Chunk &el)
 {
-  RDCCOMPILE_ASSERT((uint32_t)D3D12Chunk::Max == 1133, "Chunks changed without updating names");
+  RDCCOMPILE_ASSERT((uint32_t)D3D12Chunk::Max == 1137, "Chunks changed without updating names");

  BEGIN_ENUM_STRINGISE(D3D12Chunk)
  {
@@ -236,6 +236,12 @@ rdcstr DoStringise(const D3D12Chunk &el)
    STRINGISE_ENUM_CLASS_NAMED(CreateAS, "Internal::Acceleration Structure Create");
    STRINGISE_ENUM_CLASS_NAMED(StateObject_SetPipelineStackSize,
                               "ID3D12StateObjectProperties::SetPipelineStackSize");
+    STRINGISE_ENUM_CLASS_NAMED(Device_CreateHeapFromAddress1,
+                               "ID3D12Device13::OpenExistingHeapFromAddress1");
+    STRINGISE_ENUM_CLASS_NAMED(Device_CreateRootSignatureFromSubobjectInLibrary,
+                               "ID3D12Device14::CreateRootSignatureFromSubobjectInLibrary");
+    STRINGISE_ENUM_CLASS_NAMED(List_SetProgram, "ID3D12GraphicsCommandList10::SetProgram");
+    STRINGISE_ENUM_CLASS_NAMED(List_DispatchGraph, "ID3D12GraphicsCommandList10::DispatchGraph");
    STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk");
  }
  END_ENUM_STRINGISE()
@@ -757,6 +763,7 @@ rdcstr DoStringise(const D3D12_INDIRECT_ARGUMENT_TYPE &el)
    STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW)
    STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS)
    STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH)
+    STRINGISE_ENUM(D3D12_INDIRECT_ARGUMENT_TYPE_INCREMENTING_CONSTANT)
  }
  END_ENUM_STRINGISE();
 }
@@ -1223,6 +1230,7 @@ rdcstr DoStringise(const D3D12_RESOURCE_FLAGS &el)
    STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY);
    STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY);
    STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE);
+    STRINGISE_BITFIELD_BIT(D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT);
  }
  END_BITFIELD_STRINGISE();
 }
@@ -1598,6 +1606,23 @@ rdcstr DoStringise(const D3D12_STATE_SUBOBJECT_TYPE &el)
    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG);
    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP);
    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_WORK_GRAPH);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_BLEND);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_SAMPLE_MASK);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_RASTERIZER);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_SAMPLE_DESC);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_FLAGS);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_GENERIC_PROGRAM);
+    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL2);
    STRINGISE_ENUM(D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID);
  }
  END_ENUM_STRINGISE();
@@ -1612,6 +1637,7 @@ rdcstr DoStringise(const D3D12_STATE_OBJECT_FLAGS &el)
    STRINGISE_ENUM(D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS);
    STRINGISE_ENUM(D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS);
    STRINGISE_ENUM(D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS);
+    STRINGISE_ENUM(D3D12_STATE_OBJECT_FLAG_WORK_GRAPHS_USE_GRAPHICS_STATE_FOR_GLOBAL_ROOT_SIGNATURE);
  }
  END_ENUM_STRINGISE();
 }
@@ -1656,6 +1682,7 @@ rdcstr DoStringise(const D3D12_STATE_OBJECT_TYPE &el)
  {
    STRINGISE_ENUM(D3D12_STATE_OBJECT_TYPE_COLLECTION);
    STRINGISE_ENUM(D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE);
+    STRINGISE_ENUM(D3D12_STATE_OBJECT_TYPE_EXECUTABLE);
  }
  END_ENUM_STRINGISE();
 }
@@ -102,6 +102,7 @@
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="d3d12_commands.cpp" />
+    <ClCompile Include="d3d12_command_list10_wrap.cpp" />
    <ClCompile Include="d3d12_command_list1_wrap.cpp" />
    <ClCompile Include="d3d12_command_list2_wrap.cpp" />
    <ClCompile Include="d3d12_command_list3_wrap.cpp" />
@@ -122,6 +123,8 @@
    <ClCompile Include="d3d12_device_wrap1.cpp" />
    <ClCompile Include="d3d12_device_wrap11.cpp" />
    <ClCompile Include="d3d12_device_wrap12.cpp" />
+    <ClCompile Include="d3d12_device_wrap13.cpp" />
+    <ClCompile Include="d3d12_device_wrap14.cpp" />
    <ClCompile Include="d3d12_device_wrap2.cpp" />
    <ClCompile Include="d3d12_device_wrap3.cpp" />
    <ClCompile Include="d3d12_device_wrap4.cpp" />
@@ -245,5 +245,14 @@
    <ClCompile Include="d3d12_rootsig.cpp">
      <Filter>Util</Filter>
    </ClCompile>
+    <ClCompile Include="d3d12_device_wrap13.cpp">
+      <Filter>Wrapped</Filter>
+    </ClCompile>
+    <ClCompile Include="d3d12_device_wrap14.cpp">
+      <Filter>Wrapped</Filter>
+    </ClCompile>
+    <ClCompile Include="d3d12_command_list10_wrap.cpp">
+      <Filter>Wrapped</Filter>
+    </ClCompile>
  </ItemGroup>
 </Project>
@@ -0,0 +1,819 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12compatibility_h__
+#define __d3d12compatibility_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12CompatibilityDevice_FWD_DEFINED__
+#define __ID3D12CompatibilityDevice_FWD_DEFINED__
+typedef interface ID3D12CompatibilityDevice ID3D12CompatibilityDevice;
+
+#endif 	/* __ID3D12CompatibilityDevice_FWD_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_FWD_DEFINED__
+#define __D3D11On12CreatorID_FWD_DEFINED__
+typedef interface D3D11On12CreatorID D3D11On12CreatorID;
+
+#endif 	/* __D3D11On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_FWD_DEFINED__
+#define __D3D9On12CreatorID_FWD_DEFINED__
+typedef interface D3D9On12CreatorID D3D9On12CreatorID;
+
+#endif 	/* __D3D9On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_FWD_DEFINED__
+#define __OpenGLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenGLOn12CreatorID OpenGLOn12CreatorID;
+
+#endif 	/* __OpenGLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_FWD_DEFINED__
+#define __OpenCLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenCLOn12CreatorID OpenCLOn12CreatorID;
+
+#endif 	/* __OpenCLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __VulkanOn12CreatorID_FWD_DEFINED__
+#define __VulkanOn12CreatorID_FWD_DEFINED__
+typedef interface VulkanOn12CreatorID VulkanOn12CreatorID;
+
+#endif 	/* __VulkanOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+#define __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+typedef interface DirectMLTensorFlowCreatorID DirectMLTensorFlowCreatorID;
+
+#endif 	/* __DirectMLTensorFlowCreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_FWD_DEFINED__
+#define __DirectMLPyTorchCreatorID_FWD_DEFINED__
+typedef interface DirectMLPyTorchCreatorID DirectMLPyTorchCreatorID;
+
+#endif 	/* __DirectMLPyTorchCreatorID_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+//#include "d3d11on12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region Desktop Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+typedef 
+enum D3D12_COMPATIBILITY_SHARED_FLAGS
+    {
+        D3D12_COMPATIBILITY_SHARED_FLAG_NONE	= 0,
+        D3D12_COMPATIBILITY_SHARED_FLAG_NON_NT_HANDLE	= 0x1,
+        D3D12_COMPATIBILITY_SHARED_FLAG_KEYED_MUTEX	= 0x2,
+        D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12	= 0x4
+    } 	D3D12_COMPATIBILITY_SHARED_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS )
+typedef 
+enum D3D12_REFLECT_SHARED_PROPERTY
+    {
+        D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS	= 0,
+        D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS	= ( D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS + 1 ) ,
+        D3D12_REFLECT_SHARED_PROPERTY_NON_NT_SHARED_HANDLE	= ( D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS + 1 ) 
+    } 	D3D12_REFLECT_SHARED_PROPERTY;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+#define __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12CompatibilityDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompatibilityDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8f1c0e3c-fae3-4a82-b098-bfe1708207ff")
+    ID3D12CompatibilityDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedResource( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedHeap( 
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReflectSharedProperties( 
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompatibilityDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompatibilityDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedResource )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHeap )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, ReflectSharedProperties)
+        HRESULT ( STDMETHODCALLTYPE *ReflectSharedProperties )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12CompatibilityDeviceVtbl;
+
+    interface ID3D12CompatibilityDevice
+    {
+        CONST_VTBL struct ID3D12CompatibilityDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompatibilityDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompatibilityDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompatibilityDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompatibilityDevice_CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource)	\
+    ( (This)->lpVtbl -> CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource) ) 
+
+#define ID3D12CompatibilityDevice_CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap)	\
+    ( (This)->lpVtbl -> CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap) ) 
+
+#define ID3D12CompatibilityDevice_ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize)	\
+    ( (This)->lpVtbl -> ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompatibilityDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_INTERFACE_DEFINED__
+#define __D3D11On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D11On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D11On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("edbf5678-2960-4e81-8429-99d4b2630c4e")
+    D3D11On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D11On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D11On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D11On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D11On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D11On12CreatorIDVtbl;
+
+    interface D3D11On12CreatorID
+    {
+        CONST_VTBL struct D3D11On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D11On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D11On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D11On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D11On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_INTERFACE_DEFINED__
+#define __D3D9On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D9On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D9On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fffcbb7f-15d3-42a2-841e-9d8d32f37ddd")
+    D3D9On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D9On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D9On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D9On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D9On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D9On12CreatorIDVtbl;
+
+    interface D3D9On12CreatorID
+    {
+        CONST_VTBL struct D3D9On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D9On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D9On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D9On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D9On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenGLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenGLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6bb3cd34-0d19-45ab-97ed-d720ba3dfc80")
+    OpenGLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenGLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenGLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenGLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenGLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenGLOn12CreatorIDVtbl;
+
+    interface OpenGLOn12CreatorID
+    {
+        CONST_VTBL struct OpenGLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenGLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenGLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenGLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenGLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenCLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenCLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3f76bb74-91b5-4a88-b126-20ca0331cd60")
+    OpenCLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenCLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenCLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenCLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenCLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenCLOn12CreatorIDVtbl;
+
+    interface OpenCLOn12CreatorID
+    {
+        CONST_VTBL struct OpenCLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenCLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenCLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenCLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenCLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __VulkanOn12CreatorID_INTERFACE_DEFINED__
+#define __VulkanOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface VulkanOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_VulkanOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("bc806e01-3052-406c-a3e8-9fc07f048f98")
+    VulkanOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct VulkanOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            VulkanOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            VulkanOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            VulkanOn12CreatorID * This);
+        
+        END_INTERFACE
+    } VulkanOn12CreatorIDVtbl;
+
+    interface VulkanOn12CreatorID
+    {
+        CONST_VTBL struct VulkanOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define VulkanOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define VulkanOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define VulkanOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __VulkanOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+#define __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLTensorFlowCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLTensorFlowCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("cb7490ac-8a0f-44ec-9b7b-6f4cafe8e9ab")
+    DirectMLTensorFlowCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLTensorFlowCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLTensorFlowCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLTensorFlowCreatorIDVtbl;
+
+    interface DirectMLTensorFlowCreatorID
+    {
+        CONST_VTBL struct DirectMLTensorFlowCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLTensorFlowCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLTensorFlowCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLTensorFlowCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+#define __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLPyTorchCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLPyTorchCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("af029192-fba1-4b05-9116-235e06560354")
+    DirectMLPyTorchCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLPyTorchCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLPyTorchCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLPyTorchCreatorIDVtbl;
+
+    interface DirectMLPyTorchCreatorID
+    {
+        CONST_VTBL struct DirectMLPyTorchCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLPyTorchCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLPyTorchCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLPyTorchCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0008 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12CompatibilityDevice,0x8f1c0e3c,0xfae3,0x4a82,0xb0,0x98,0xbf,0xe1,0x70,0x82,0x07,0xff);
+DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4,0xb2,0x63,0x0c,0x4e);
+DEFINE_GUID(IID_D3D9On12CreatorID,0xfffcbb7f,0x15d3,0x42a2,0x84,0x1e,0x9d,0x8d,0x32,0xf3,0x7d,0xdd);
+DEFINE_GUID(IID_OpenGLOn12CreatorID,0x6bb3cd34,0x0d19,0x45ab,0x97,0xed,0xd7,0x20,0xba,0x3d,0xfc,0x80);
+DEFINE_GUID(IID_OpenCLOn12CreatorID,0x3f76bb74,0x91b5,0x4a88,0xb1,0x26,0x20,0xca,0x03,0x31,0xcd,0x60);
+DEFINE_GUID(IID_VulkanOn12CreatorID,0xbc806e01,0x3052,0x406c,0xa3,0xe8,0x9f,0xc0,0x7f,0x04,0x8f,0x98);
+DEFINE_GUID(IID_DirectMLTensorFlowCreatorID,0xcb7490ac,0x8a0f,0x44ec,0x9b,0x7b,0x6f,0x4c,0xaf,0xe8,0xe9,0xab);
+DEFINE_GUID(IID_DirectMLPyTorchCreatorID,0xaf029192,0xfba1,0x4b05,0x91,0x16,0x23,0x5e,0x06,0x56,0x03,0x54);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0008_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0008_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+
@@ -2467,6 +2467,9 @@ enum D3D12_MESSAGE_ID
        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA	= 115,
        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA	= 116,
        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK	= 117,
+        D3D12_MESSAGE_ID_GET_PROGRAM_IDENTIFIER_ERROR	= 118,
+        D3D12_MESSAGE_ID_GET_WORK_GRAPH_PROPERTIES_ERROR	= 119,
+        D3D12_MESSAGE_ID_SET_PROGRAM_ERROR	= 120,
        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID	= 135,
        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET	= 200,
        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH	= 201,
@@ -3303,7 +3306,48 @@ enum D3D12_MESSAGE_ID
        D3D12_MESSAGE_ID_DRAW_POTENTIALLY_OUTSIDE_OF_VALID_RENDER_AREA	= 1378,
        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_LINERASTERIZATIONMODE	= 1379,
        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT_SMALLRESOURCE	= 1380,
-        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT_SMALLRESOURCE + 1 ) 
+        D3D12_MESSAGE_ID_GENERIC_DEVICE_OPERATION_UNSUPPORTED	= 1381,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDER_TARGET_WRONG_WRITE_MASK	= 1382,
+        D3D12_MESSAGE_ID_PROBABLE_PIX_EVENT_LEAK	= 1383,
+        D3D12_MESSAGE_ID_PIX_EVENT_UNDERFLOW	= 1384,
+        D3D12_MESSAGE_ID_RECREATEAT_INVALID_TARGET	= 1385,
+        D3D12_MESSAGE_ID_RECREATEAT_INSUFFICIENT_SUPPORT	= 1386,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_STRUCTURED_BUFFER_STRIDE_MISMATCH	= 1387,
+        D3D12_MESSAGE_ID_DISPATCH_GRAPH_INVALID	= 1388,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_TARGET_FORMAT_INVALID	= 1389,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_TARGET_DIMENSION_INVALID	= 1390,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_SOURCE_COLOR_FORMAT_INVALID	= 1391,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_SOURCE_DEPTH_FORMAT_INVALID	= 1392,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXPOSURE_SCALE_FORMAT_INVALID	= 1393,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_ENGINE_CREATE_FLAGS_INVALID	= 1394,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_LOAD_FAILURE	= 1395,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_ENGINE_CREATION_ERROR	= 1396,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_UPSCALER_CREATION_ERROR	= 1397,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_EXTENSION_INTERNAL_UPSCALER_EXECUTION_ERROR	= 1398,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_REGION_INVALID	= 1399,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_TIME_DELTA_INVALID	= 1400,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_REQUIRED_TEXTURE_IS_NULL	= 1401,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_MOTION_VECTORS_FORMAT_INVALID	= 1402,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_FLAGS_INVALID	= 1403,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_FORMAT_INVALID	= 1404,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_EXPOSURE_SCALE_TEXTURE_SIZE_INVALID	= 1405,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_VARIANT_INDEX_OUT_OF_BOUNDS	= 1406,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_VARIANT_ID_NOT_FOUND	= 1407,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_DUPLICATE_VARIANT_ID	= 1408,
+        D3D12_MESSAGE_ID_DIRECTSR_OUT_OF_MEMORY	= 1409,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_UNEXPECTED_TEXTURE_IS_IGNORED	= 1410,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EVICT_UNDERFLOW	= 1411,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_OPTIONAL_TEXTURE_IS_NULL	= 1412,
+        D3D12_MESSAGE_ID_DIRECTSR_SUPERRES_UPSCALER_EXECUTE_INVALID_CAMERA_JITTER	= 1413,
+        D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_WARNING	= 1414,
+        D3D12_MESSAGE_ID_GUID_TEXTURE_LAYOUT_UNSUPPORTED	= 1415,
+        D3D12_MESSAGE_ID_RESOLVE_ENCODER_INPUT_PARAM_LAYOUT_INVALID_PARAMETERS	= 1416,
+        D3D12_MESSAGE_ID_INVALID_BARRIER_ACCESS	= 1417,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INSTANCE_COUNT_ZERO	= 1418,
+        D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SET_BEFORE_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG	= 1419,
+        D3D12_MESSAGE_ID_DIFFERENT_DESCRIPTOR_HEAP_SET_AFTER_ROOT_SIGNATURE_WITH_DIRECTLY_INDEXED_FLAG	= 1420,
+        D3D12_MESSAGE_ID_APPLICATION_SPECIFIC_DRIVER_STATE_NOT_SUPPORTED	= 1421,
+        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_APPLICATION_SPECIFIC_DRIVER_STATE_NOT_SUPPORTED + 1 ) 
    } 	D3D12_MESSAGE_ID;

 typedef struct D3D12_MESSAGE
@@ -3821,7 +3865,7 @@ EXTERN_C const IID IID_ID3D12InfoQueue1;
        virtual HRESULT STDMETHODCALLTYPE RegisterMessageCallback( 
            _In_  D3D12MessageFunc CallbackFunc,
            _In_  D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags,
-            _In_  void *pContext,
+            _Inout_  void *pContext,
            _Inout_  DWORD *pCallbackCookie) = 0;
        
        virtual HRESULT STDMETHODCALLTYPE UnregisterMessageCallback( 
@@ -4023,7 +4067,7 @@ EXTERN_C const IID IID_ID3D12InfoQueue1;
            ID3D12InfoQueue1 * This,
            _In_  D3D12MessageFunc CallbackFunc,
            _In_  D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags,
-            _In_  void *pContext,
+            _Inout_  void *pContext,
            _Inout_  DWORD *pCallbackCookie);
        
        DECLSPEC_XFGVIRT(ID3D12InfoQueue1, UnregisterMessageCallback)
@@ -93,6 +93,7 @@ enum D3D_DRIVER_TYPE
 typedef 
 enum D3D_FEATURE_LEVEL
    {
+        D3D_FEATURE_LEVEL_1_0_GENERIC	= 0x100,
        D3D_FEATURE_LEVEL_1_0_CORE	= 0x1000,
        D3D_FEATURE_LEVEL_9_1	= 0x9100,
        D3D_FEATURE_LEVEL_9_2	= 0x9200,
@@ -389,6 +390,10 @@ enum D3D_SRV_DIMENSION
 #define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                       0x10000000
 #define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                           0x20000000
 #define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                        0x40000000
+#define D3D_SHADER_FEATURE_SAMPLE_CMP_GRADIENT_OR_BIAS                                    0x80000000
+#define D3D_SHADER_FEATURE_EXTENDED_COMMAND_INFO                                          0x100000000ull
+#define D3D_OPT_SHADER_FEATURE_USES_DERIVATIVES                                         0x0000010000000000ull
+#define D3D_OPT_SHADER_FEATURE_REQUIRES_GROUP                                           0x0000020000000000ull
 typedef struct _D3D_SHADER_MACRO
    {
    LPCSTR Name;
@@ -960,10 +965,22 @@ enum D3D_REGISTER_COMPONENT_TYPE
        D3D_REGISTER_COMPONENT_UINT32	= 1,
        D3D_REGISTER_COMPONENT_SINT32	= 2,
        D3D_REGISTER_COMPONENT_FLOAT32	= 3,
+        D3D_REGISTER_COMPONENT_UINT16	= 4,
+        D3D_REGISTER_COMPONENT_SINT16	= 5,
+        D3D_REGISTER_COMPONENT_FLOAT16	= 6,
+        D3D_REGISTER_COMPONENT_UINT64	= 7,
+        D3D_REGISTER_COMPONENT_SINT64	= 8,
+        D3D_REGISTER_COMPONENT_FLOAT64	= 9,
        D3D10_REGISTER_COMPONENT_UNKNOWN	= D3D_REGISTER_COMPONENT_UNKNOWN,
        D3D10_REGISTER_COMPONENT_UINT32	= D3D_REGISTER_COMPONENT_UINT32,
        D3D10_REGISTER_COMPONENT_SINT32	= D3D_REGISTER_COMPONENT_SINT32,
-        D3D10_REGISTER_COMPONENT_FLOAT32	= D3D_REGISTER_COMPONENT_FLOAT32
+        D3D10_REGISTER_COMPONENT_FLOAT32	= D3D_REGISTER_COMPONENT_FLOAT32,
+        D3D10_REGISTER_COMPONENT_UINT16	= D3D_REGISTER_COMPONENT_UINT16,
+        D3D10_REGISTER_COMPONENT_SINT16	= D3D_REGISTER_COMPONENT_SINT16,
+        D3D10_REGISTER_COMPONENT_FLOAT16	= D3D_REGISTER_COMPONENT_FLOAT16,
+        D3D10_REGISTER_COMPONENT_UINT64	= D3D_REGISTER_COMPONENT_UINT64,
+        D3D10_REGISTER_COMPONENT_SINT64	= D3D_REGISTER_COMPONENT_SINT64,
+        D3D10_REGISTER_COMPONENT_FLOAT64	= D3D_REGISTER_COMPONENT_FLOAT64
    } 	D3D_REGISTER_COMPONENT_TYPE;

 typedef 
@@ -1,5 +1,6 @@
 //
-//    Copyright (C) Microsoft.  All rights reserved.
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
 //

 #ifndef __dxgicommon_h__
@@ -170,6 +170,8 @@ rdcstr DoStringise(const D3D_FEATURE_LEVEL &el)
 {
  BEGIN_ENUM_STRINGISE(D3D_FEATURE_LEVEL);
  {
+    STRINGISE_ENUM(D3D_FEATURE_LEVEL_1_0_GENERIC)
+    STRINGISE_ENUM(D3D_FEATURE_LEVEL_1_0_CORE)
    STRINGISE_ENUM(D3D_FEATURE_LEVEL_9_1)
    STRINGISE_ENUM(D3D_FEATURE_LEVEL_9_2)
    STRINGISE_ENUM(D3D_FEATURE_LEVEL_9_3)
@@ -253,6 +253,8 @@ public:
  bool GetPipelineValidation(DXIL::PSVData &psv) const;
  bool GetRuntimeData(DXIL::RDATData &rdat) const;

+  static bool GetRuntimeData(const byte *RDATChunk, size_t RDATLength, DXIL::RDATData &rdat);
+
  static void SetPipelineValidation(bytebuf &ByteCode, const DXIL::PSVData &psv);
  static void SetRuntimeData(bytebuf &ByteCode, const DXIL::RDATData &rdat);

@@ -789,12 +789,17 @@ void DXBCContainer::SetPipelineValidation(bytebuf &ByteCode, const DXIL::PSVData

 bool DXBCContainer::GetRuntimeData(DXIL::RDATData &rdat) const
 {
-  using namespace DXIL;
-
  if(m_RDATOffset == 0)
    return false;

-  const byte *in = m_ShaderBlob.data() + m_RDATOffset;
+  return GetRuntimeData(m_ShaderBlob.data() + m_RDATOffset, m_RDATSize, rdat);
+}
+
+bool DXBCContainer::GetRuntimeData(const byte *RDATChunk, size_t RDATLength, DXIL::RDATData &rdat)
+{
+  using namespace DXIL;
+
+  const byte *in = RDATChunk;

  // RDAT Header
  uint32_t *ver = (uint32_t *)in;