Updated D3D headers.

3rdparty/directx-headers/include/directx/PIXEvents.h

@@ -13,15 +13,6 @@
 
 #include "PIXEventsCommon.h"
 
-#if _MSC_VER < 1800
-# error This version of pix3.h is only supported on Visual Studio 2013 or higher
-#elif _MSC_VER < 1900
-# ifndef constexpr // Visual Studio 2013 doesn't support constexpr
-#  define constexpr
-#  define PIX3__DEFINED_CONSTEXPR
-# endif
-#endif
-
  // Xbox does not support CPU events for retail scenarios
 #if defined(USE_PIX) || !defined(PIX_XBOX)
 #define PIX_CONTEXT_EMIT_CPU_EVENTS

3rdparty/directx-headers/include/directx/d3d12compatibility.h

@@ -87,6 +87,13 @@ 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;
@@ -101,6 +108,13 @@ typedef interface DirectMLPyTorchCreatorID DirectMLPyTorchCreatorID;
 #endif 	/* __DirectMLPyTorchCreatorID_FWD_DEFINED__ */
 
 
+#ifndef __DirectMLWebNNCreatorID_FWD_DEFINED__
+#define __DirectMLWebNNCreatorID_FWD_DEFINED__
+typedef interface DirectMLWebNNCreatorID DirectMLWebNNCreatorID;
+
+#endif 	/* __DirectMLWebNNCreatorID_FWD_DEFINED__ */
+
+
 /* header files for imported files */
 #include "oaidl.h"
 #include "ocidl.h"
@@ -126,7 +140,7 @@ enum D3D12_COMPATIBILITY_SHARED_FLAGS
         D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12	= 0x4
     } 	D3D12_COMPATIBILITY_SHARED_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS );
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS )
 typedef 
 enum D3D12_REFLECT_SHARED_PROPERTY
     {
@@ -565,6 +579,78 @@ EXTERN_C const IID IID_OpenCLOn12CreatorID;
 #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__
 
@@ -709,7 +795,79 @@ EXTERN_C const IID IID_DirectMLPyTorchCreatorID;
 #endif 	/* __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__ */
 
 
-/* interface __MIDL_itf_d3d12compatibility_0000_0007 */
+#ifndef __DirectMLWebNNCreatorID_INTERFACE_DEFINED__
+#define __DirectMLWebNNCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLWebNNCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLWebNNCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fdf01a76-1e11-450f-902b-74f04ea08094")
+    DirectMLWebNNCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLWebNNCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLWebNNCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLWebNNCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLWebNNCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLWebNNCreatorIDVtbl;
+
+    interface DirectMLWebNNCreatorID
+    {
+        CONST_VTBL struct DirectMLWebNNCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLWebNNCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLWebNNCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLWebNNCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLWebNNCreatorID_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0009 */
 /* [local] */ 
 
 #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
@@ -719,12 +877,14 @@ DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4,
 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);
+DEFINE_GUID(IID_DirectMLWebNNCreatorID,0xfdf01a76,0x1e11,0x450f,0x90,0x2b,0x74,0xf0,0x4e,0xa0,0x80,0x94);
 
 
-extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_s_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0009_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0009_v0_0_s_ifspec;
 
 /* Additional Prototypes for ALL interfaces */
 

3rdparty/directx-headers/include/directx/d3d12compiler.h

@@ -0,0 +1,977 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * 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 __d3d12compiler_h__
+#define __d3d12compiler_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 __ID3D12CompilerFactoryChild_FWD_DEFINED__
+#define __ID3D12CompilerFactoryChild_FWD_DEFINED__
+typedef interface ID3D12CompilerFactoryChild ID3D12CompilerFactoryChild;
+
+#endif 	/* __ID3D12CompilerFactoryChild_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CompilerCacheSession_FWD_DEFINED__
+#define __ID3D12CompilerCacheSession_FWD_DEFINED__
+typedef interface ID3D12CompilerCacheSession ID3D12CompilerCacheSession;
+
+#endif 	/* __ID3D12CompilerCacheSession_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CompilerStateObject_FWD_DEFINED__
+#define __ID3D12CompilerStateObject_FWD_DEFINED__
+typedef interface ID3D12CompilerStateObject ID3D12CompilerStateObject;
+
+#endif 	/* __ID3D12CompilerStateObject_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Compiler_FWD_DEFINED__
+#define __ID3D12Compiler_FWD_DEFINED__
+typedef interface ID3D12Compiler ID3D12Compiler;
+
+#endif 	/* __ID3D12Compiler_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CompilerFactory_FWD_DEFINED__
+#define __ID3D12CompilerFactory_FWD_DEFINED__
+typedef interface ID3D12CompilerFactory ID3D12CompilerFactory;
+
+#endif 	/* __ID3D12CompilerFactory_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "dxgicommon.h"
+#include "d3d12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12compiler_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+typedef struct D3D12_ADAPTER_FAMILY
+    {
+    WCHAR szAdapterFamily[ 128 ];
+    } 	D3D12_ADAPTER_FAMILY;
+
+typedef HRESULT (WINAPI* PFN_D3D12_COMPILER_CREATE_FACTORY)( 
+    _In_ LPCWSTR pPluginCompilerDllPath,
+    _In_ REFIID riid,
+    _COM_Outptr_opt_ void** ppFactory );
+
+HRESULT WINAPI D3D12CompilerCreateFactory(
+    _In_ LPCWSTR pPluginCompilerDllPath,
+    _In_ REFIID riid, // Expected: ID3D12CompilerFactory
+    _COM_Outptr_opt_ void** ppFactory );
+
+typedef HRESULT (WINAPI* PFN_D3D12_COMPILER_SERIALIZE_VERSIONED_ROOT_SIGNATURE)(
+                            _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature,
+                            _Out_ ID3DBlob** ppBlob,
+                            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob);
+
+HRESULT WINAPI D3D12CompilerSerializeVersionedRootSignature(
+                            _In_ const D3D12_VERSIONED_ROOT_SIGNATURE_DESC* pRootSignature,
+                            _Out_ ID3DBlob** ppBlob,
+                            _Always_(_Outptr_opt_result_maybenull_) ID3DBlob** ppErrorBlob);
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12CompilerFactoryChild_INTERFACE_DEFINED__
+#define __ID3D12CompilerFactoryChild_INTERFACE_DEFINED__
+
+/* interface ID3D12CompilerFactoryChild */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompilerFactoryChild;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("e0d06420-9f31-47e8-ae9a-dd2ba25ac0bc")
+    ID3D12CompilerFactoryChild : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetFactory( 
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerFactory) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompilerFactoryChildVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompilerFactoryChild * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompilerFactoryChild * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompilerFactoryChild * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactoryChild, GetFactory)
+        HRESULT ( STDMETHODCALLTYPE *GetFactory )( 
+            ID3D12CompilerFactoryChild * This,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerFactory);
+        
+        END_INTERFACE
+    } ID3D12CompilerFactoryChildVtbl;
+
+    interface ID3D12CompilerFactoryChild
+    {
+        CONST_VTBL struct ID3D12CompilerFactoryChildVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompilerFactoryChild_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompilerFactoryChild_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompilerFactoryChild_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompilerFactoryChild_GetFactory(This,riid,ppCompilerFactory)	\
+    ( (This)->lpVtbl -> GetFactory(This,riid,ppCompilerFactory) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompilerFactoryChild_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compiler_0000_0001 */
+/* [local] */ 
+
+typedef 
+enum D3D12_COMPILER_VALUE_TYPE
+    {
+        D3D12_COMPILER_VALUE_TYPE_OBJECT_CODE	= 0,
+        D3D12_COMPILER_VALUE_TYPE_METADATA	= 1,
+        D3D12_COMPILER_VALUE_TYPE_DEBUG_PDB	= 2,
+        D3D12_COMPILER_VALUE_TYPE_PERFORMANCE_DATA	= 3
+    } 	D3D12_COMPILER_VALUE_TYPE;
+
+typedef 
+enum D3D12_COMPILER_VALUE_TYPE_FLAGS
+    {
+        D3D12_COMPILER_VALUE_TYPE_FLAGS_NONE	= 0,
+        D3D12_COMPILER_VALUE_TYPE_FLAGS_OBJECT_CODE	= ( 1 << D3D12_COMPILER_VALUE_TYPE_OBJECT_CODE ) ,
+        D3D12_COMPILER_VALUE_TYPE_FLAGS_METADATA	= ( 1 << D3D12_COMPILER_VALUE_TYPE_METADATA ) ,
+        D3D12_COMPILER_VALUE_TYPE_FLAGS_DEBUG_PDB	= ( 1 << D3D12_COMPILER_VALUE_TYPE_DEBUG_PDB ) ,
+        D3D12_COMPILER_VALUE_TYPE_FLAGS_PERFORMANCE_DATA	= ( 1 << D3D12_COMPILER_VALUE_TYPE_PERFORMANCE_DATA ) 
+    } 	D3D12_COMPILER_VALUE_TYPE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPILER_VALUE_TYPE_FLAGS )
+typedef struct D3D12_COMPILER_DATABASE_PATH
+    {
+    D3D12_COMPILER_VALUE_TYPE_FLAGS Types;
+    LPCWSTR pPath;
+    } 	D3D12_COMPILER_DATABASE_PATH;
+
+typedef struct D3D12_COMPILER_CACHE_GROUP_KEY
+    {
+    _Field_size_bytes_full_(KeySize)  const void *pKey;
+    UINT KeySize;
+    } 	D3D12_COMPILER_CACHE_GROUP_KEY;
+
+typedef struct D3D12_COMPILER_CACHE_VALUE_KEY
+    {
+    _Field_size_bytes_full_(KeySize)  const void *pKey;
+    UINT KeySize;
+    } 	D3D12_COMPILER_CACHE_VALUE_KEY;
+
+typedef struct D3D12_COMPILER_CACHE_VALUE
+    {
+    _Field_size_bytes_full_(ValueSize)  void *pValue;
+    UINT ValueSize;
+    } 	D3D12_COMPILER_CACHE_VALUE;
+
+typedef struct D3D12_COMPILER_CACHE_TYPED_VALUE
+    {
+    D3D12_COMPILER_VALUE_TYPE Type;
+    D3D12_COMPILER_CACHE_VALUE Value;
+    } 	D3D12_COMPILER_CACHE_TYPED_VALUE;
+
+typedef struct D3D12_COMPILER_CACHE_CONST_VALUE
+    {
+    _Field_size_bytes_full_(ValueSize)  const void *pValue;
+    UINT ValueSize;
+    } 	D3D12_COMPILER_CACHE_CONST_VALUE;
+
+typedef struct D3D12_COMPILER_CACHE_TYPED_CONST_VALUE
+    {
+    D3D12_COMPILER_VALUE_TYPE Type;
+    D3D12_COMPILER_CACHE_CONST_VALUE Value;
+    } 	D3D12_COMPILER_CACHE_TYPED_CONST_VALUE;
+
+typedef struct D3D12_COMPILER_TARGET
+    {
+    UINT AdapterFamilyIndex;
+    UINT64 ABIVersion;
+    } 	D3D12_COMPILER_TARGET;
+
+typedef void *( __stdcall *D3D12CompilerCacheSessionAllocationFunc )( 
+    SIZE_T SizeInBytes,
+    _Inout_opt_  void *pContext);
+
+typedef void ( __stdcall *D3D12CompilerCacheSessionGroupValueKeysFunc )( 
+    _In_  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey,
+    _Inout_opt_  void *pContext);
+
+typedef void ( __stdcall *D3D12CompilerCacheSessionGroupValuesFunc )( 
+    UINT ValueKeyIndex,
+    _In_  const D3D12_COMPILER_CACHE_TYPED_CONST_VALUE *pTypedValue,
+    _Inout_opt_  void *pContext);
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3D12CompilerCacheSession_INTERFACE_DEFINED__
+#define __ID3D12CompilerCacheSession_INTERFACE_DEFINED__
+
+/* interface ID3D12CompilerCacheSession */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompilerCacheSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5704e5e6-054b-4738-b661-7b0d68d8dde2")
+    ID3D12CompilerCacheSession : public ID3D12CompilerFactoryChild
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE FindGroup( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            _Out_opt_  UINT *pGroupVersion) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE FindGroupValueKeys( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            _In_opt_  const UINT *pExpectedGroupVersion,
+            _In_  D3D12CompilerCacheSessionGroupValueKeysFunc CallbackFunc,
+            _Inout_opt_  void *pContext) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE FindGroupValues( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            _In_opt_  const UINT *pExpectedGroupVersion,
+            D3D12_COMPILER_VALUE_TYPE_FLAGS ValueTypeFlags,
+            _In_opt_  D3D12CompilerCacheSessionGroupValuesFunc CallbackFunc,
+            _Inout_opt_  void *pContext) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE FindValue( 
+            _In_  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey,
+            _Inout_count_(NumTypedValues)  D3D12_COMPILER_CACHE_TYPED_VALUE *pTypedValues,
+            UINT NumTypedValues,
+            _In_opt_  D3D12CompilerCacheSessionAllocationFunc pCallbackFunc,
+            _Inout_opt_  void *pContext) = 0;
+        
+        virtual const D3D12_APPLICATION_DESC *STDMETHODCALLTYPE GetApplicationDesc( void) = 0;
+        
+#if BX_COMPILER_MSVC || (BX_COMPILER_CLANG && defined(_MSC_VER) )
+        virtual D3D12_COMPILER_TARGET STDMETHODCALLTYPE GetCompilerTarget( void) = 0;
+#else
+        virtual D3D12_COMPILER_TARGET *STDMETHODCALLTYPE GetCompilerTarget( 
+            D3D12_COMPILER_TARGET * RetVal) = 0;
+#endif
+        
+        virtual D3D12_COMPILER_VALUE_TYPE_FLAGS STDMETHODCALLTYPE GetValueTypes( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE StoreGroupValueKeys( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_reads_(NumValueKeys)  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKeys,
+            UINT NumValueKeys) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE StoreValue( 
+            _In_  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey,
+            _In_reads_(NumTypedValues)  const D3D12_COMPILER_CACHE_TYPED_CONST_VALUE *pTypedValues,
+            UINT NumTypedValues) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompilerCacheSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompilerCacheSession * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompilerCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompilerCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactoryChild, GetFactory)
+        HRESULT ( STDMETHODCALLTYPE *GetFactory )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerFactory);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindGroup)
+        HRESULT ( STDMETHODCALLTYPE *FindGroup )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            _Out_opt_  UINT *pGroupVersion);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindGroupValueKeys)
+        HRESULT ( STDMETHODCALLTYPE *FindGroupValueKeys )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            _In_opt_  const UINT *pExpectedGroupVersion,
+            _In_  D3D12CompilerCacheSessionGroupValueKeysFunc CallbackFunc,
+            _Inout_opt_  void *pContext);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindGroupValues)
+        HRESULT ( STDMETHODCALLTYPE *FindGroupValues )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            _In_opt_  const UINT *pExpectedGroupVersion,
+            D3D12_COMPILER_VALUE_TYPE_FLAGS ValueTypeFlags,
+            _In_opt_  D3D12CompilerCacheSessionGroupValuesFunc CallbackFunc,
+            _Inout_opt_  void *pContext);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, FindValue)
+        HRESULT ( STDMETHODCALLTYPE *FindValue )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey,
+            _Inout_count_(NumTypedValues)  D3D12_COMPILER_CACHE_TYPED_VALUE *pTypedValues,
+            UINT NumTypedValues,
+            _In_opt_  D3D12CompilerCacheSessionAllocationFunc pCallbackFunc,
+            _Inout_opt_  void *pContext);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, GetApplicationDesc)
+        const D3D12_APPLICATION_DESC *( STDMETHODCALLTYPE *GetApplicationDesc )( 
+            ID3D12CompilerCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, GetCompilerTarget)
+#if !defined(_WIN32)
+        D3D12_COMPILER_TARGET ( STDMETHODCALLTYPE *GetCompilerTarget )( 
+            ID3D12CompilerCacheSession * This);
+        
+#else
+        D3D12_COMPILER_TARGET *( STDMETHODCALLTYPE *GetCompilerTarget )( 
+            ID3D12CompilerCacheSession * This,
+            D3D12_COMPILER_TARGET * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, GetValueTypes)
+        D3D12_COMPILER_VALUE_TYPE_FLAGS ( STDMETHODCALLTYPE *GetValueTypes )( 
+            ID3D12CompilerCacheSession * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, StoreGroupValueKeys)
+        HRESULT ( STDMETHODCALLTYPE *StoreGroupValueKeys )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_reads_(NumValueKeys)  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKeys,
+            UINT NumValueKeys);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerCacheSession, StoreValue)
+        HRESULT ( STDMETHODCALLTYPE *StoreValue )( 
+            ID3D12CompilerCacheSession * This,
+            _In_  const D3D12_COMPILER_CACHE_VALUE_KEY *pValueKey,
+            _In_reads_(NumTypedValues)  const D3D12_COMPILER_CACHE_TYPED_CONST_VALUE *pTypedValues,
+            UINT NumTypedValues);
+        
+        END_INTERFACE
+    } ID3D12CompilerCacheSessionVtbl;
+
+    interface ID3D12CompilerCacheSession
+    {
+        CONST_VTBL struct ID3D12CompilerCacheSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompilerCacheSession_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompilerCacheSession_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompilerCacheSession_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompilerCacheSession_GetFactory(This,riid,ppCompilerFactory)	\
+    ( (This)->lpVtbl -> GetFactory(This,riid,ppCompilerFactory) ) 
+
+
+#define ID3D12CompilerCacheSession_FindGroup(This,pGroupKey,pGroupVersion)	\
+    ( (This)->lpVtbl -> FindGroup(This,pGroupKey,pGroupVersion) ) 
+
+#define ID3D12CompilerCacheSession_FindGroupValueKeys(This,pGroupKey,pExpectedGroupVersion,CallbackFunc,pContext)	\
+    ( (This)->lpVtbl -> FindGroupValueKeys(This,pGroupKey,pExpectedGroupVersion,CallbackFunc,pContext) ) 
+
+#define ID3D12CompilerCacheSession_FindGroupValues(This,pGroupKey,pExpectedGroupVersion,ValueTypeFlags,CallbackFunc,pContext)	\
+    ( (This)->lpVtbl -> FindGroupValues(This,pGroupKey,pExpectedGroupVersion,ValueTypeFlags,CallbackFunc,pContext) ) 
+
+#define ID3D12CompilerCacheSession_FindValue(This,pValueKey,pTypedValues,NumTypedValues,pCallbackFunc,pContext)	\
+    ( (This)->lpVtbl -> FindValue(This,pValueKey,pTypedValues,NumTypedValues,pCallbackFunc,pContext) ) 
+
+#define ID3D12CompilerCacheSession_GetApplicationDesc(This)	\
+    ( (This)->lpVtbl -> GetApplicationDesc(This) ) 
+#if !defined(_WIN32)
+
+#define ID3D12CompilerCacheSession_GetCompilerTarget(This)	\
+    ( (This)->lpVtbl -> GetCompilerTarget(This) ) 
+#else
+#define ID3D12CompilerCacheSession_GetCompilerTarget(This,RetVal)	\
+    ( (This)->lpVtbl -> GetCompilerTarget(This,RetVal) ) 
+#endif
+
+#define ID3D12CompilerCacheSession_GetValueTypes(This)	\
+    ( (This)->lpVtbl -> GetValueTypes(This) ) 
+
+#define ID3D12CompilerCacheSession_StoreGroupValueKeys(This,pGroupKey,GroupVersion,pValueKeys,NumValueKeys)	\
+    ( (This)->lpVtbl -> StoreGroupValueKeys(This,pGroupKey,GroupVersion,pValueKeys,NumValueKeys) ) 
+
+#define ID3D12CompilerCacheSession_StoreValue(This,pValueKey,pTypedValues,NumTypedValues)	\
+    ( (This)->lpVtbl -> StoreValue(This,pValueKey,pTypedValues,NumTypedValues) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompilerCacheSession_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CompilerStateObject_INTERFACE_DEFINED__
+#define __ID3D12CompilerStateObject_INTERFACE_DEFINED__
+
+/* interface ID3D12CompilerStateObject */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompilerStateObject;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5981cca4-e8ae-44ca-9b92-4fa86f5a3a3a")
+    ID3D12CompilerStateObject : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetCompiler( 
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompiler) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompilerStateObjectVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompilerStateObject * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompilerStateObject * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompilerStateObject * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerStateObject, GetCompiler)
+        HRESULT ( STDMETHODCALLTYPE *GetCompiler )( 
+            ID3D12CompilerStateObject * This,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompiler);
+        
+        END_INTERFACE
+    } ID3D12CompilerStateObjectVtbl;
+
+    interface ID3D12CompilerStateObject
+    {
+        CONST_VTBL struct ID3D12CompilerStateObjectVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompilerStateObject_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompilerStateObject_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompilerStateObject_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompilerStateObject_GetCompiler(This,riid,ppCompiler)	\
+    ( (This)->lpVtbl -> GetCompiler(This,riid,ppCompiler) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompilerStateObject_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compiler_0000_0003 */
+/* [local] */ 
+
+typedef struct D3D12_COMPILER_EXISTING_COLLECTION_DESC
+    {
+    ID3D12CompilerStateObject *pExistingCollection;
+    UINT NumExports;
+    _In_reads_(NumExports)  const D3D12_EXPORT_DESC *pExports;
+    } 	D3D12_COMPILER_EXISTING_COLLECTION_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0003_v0_0_s_ifspec;
+
+#ifndef __ID3D12Compiler_INTERFACE_DEFINED__
+#define __ID3D12Compiler_INTERFACE_DEFINED__
+
+/* interface ID3D12Compiler */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Compiler;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8c403c12-993b-4583-80f1-6824138fa68e")
+    ID3D12Compiler : public ID3D12CompilerFactoryChild
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CompilePipelineState( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_  const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CompileStateObject( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_  const D3D12_STATE_OBJECT_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerStateObject) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CompileAddToStateObject( 
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_  const D3D12_STATE_OBJECT_DESC *pAddition,
+            _In_  ID3D12CompilerStateObject *pCompilerStateObjectToGrowFrom,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppNewCompilerStateObject) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCacheSession( 
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerCacheSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompilerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Compiler * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Compiler * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Compiler * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactoryChild, GetFactory)
+        HRESULT ( STDMETHODCALLTYPE *GetFactory )( 
+            ID3D12Compiler * This,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerFactory);
+        
+        DECLSPEC_XFGVIRT(ID3D12Compiler, CompilePipelineState)
+        HRESULT ( STDMETHODCALLTYPE *CompilePipelineState )( 
+            ID3D12Compiler * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_  const D3D12_PIPELINE_STATE_STREAM_DESC *pDesc);
+        
+        DECLSPEC_XFGVIRT(ID3D12Compiler, CompileStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CompileStateObject )( 
+            ID3D12Compiler * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_  const D3D12_STATE_OBJECT_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Compiler, CompileAddToStateObject)
+        HRESULT ( STDMETHODCALLTYPE *CompileAddToStateObject )( 
+            ID3D12Compiler * This,
+            _In_  const D3D12_COMPILER_CACHE_GROUP_KEY *pGroupKey,
+            UINT GroupVersion,
+            _In_  const D3D12_STATE_OBJECT_DESC *pAddition,
+            _In_  ID3D12CompilerStateObject *pCompilerStateObjectToGrowFrom,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppNewCompilerStateObject);
+        
+        DECLSPEC_XFGVIRT(ID3D12Compiler, GetCacheSession)
+        HRESULT ( STDMETHODCALLTYPE *GetCacheSession )( 
+            ID3D12Compiler * This,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerCacheSession);
+        
+        END_INTERFACE
+    } ID3D12CompilerVtbl;
+
+    interface ID3D12Compiler
+    {
+        CONST_VTBL struct ID3D12CompilerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Compiler_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Compiler_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Compiler_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Compiler_GetFactory(This,riid,ppCompilerFactory)	\
+    ( (This)->lpVtbl -> GetFactory(This,riid,ppCompilerFactory) ) 
+
+
+#define ID3D12Compiler_CompilePipelineState(This,pGroupKey,GroupVersion,pDesc)	\
+    ( (This)->lpVtbl -> CompilePipelineState(This,pGroupKey,GroupVersion,pDesc) ) 
+
+#define ID3D12Compiler_CompileStateObject(This,pGroupKey,GroupVersion,pDesc,riid,ppCompilerStateObject)	\
+    ( (This)->lpVtbl -> CompileStateObject(This,pGroupKey,GroupVersion,pDesc,riid,ppCompilerStateObject) ) 
+
+#define ID3D12Compiler_CompileAddToStateObject(This,pGroupKey,GroupVersion,pAddition,pCompilerStateObjectToGrowFrom,riid,ppNewCompilerStateObject)	\
+    ( (This)->lpVtbl -> CompileAddToStateObject(This,pGroupKey,GroupVersion,pAddition,pCompilerStateObjectToGrowFrom,riid,ppNewCompilerStateObject) ) 
+
+#define ID3D12Compiler_GetCacheSession(This,riid,ppCompilerCacheSession)	\
+    ( (This)->lpVtbl -> GetCacheSession(This,riid,ppCompilerCacheSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Compiler_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CompilerFactory_INTERFACE_DEFINED__
+#define __ID3D12CompilerFactory_INTERFACE_DEFINED__
+
+/* interface ID3D12CompilerFactory */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompilerFactory;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("c1ee4b59-3f59-47a5-9b4e-a855c858a878")
+    ID3D12CompilerFactory : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE EnumerateAdapterFamilies( 
+            UINT AdapterFamilyIndex,
+            _Out_  D3D12_ADAPTER_FAMILY *pAdapterFamily) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnumerateAdapterFamilyABIVersions( 
+            UINT AdapterFamilyIndex,
+            _Inout_  UINT32 *pNumABIVersions,
+            _Out_writes_opt_(*pNumABIVersions)  UINT64 *pABIVersions) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnumerateAdapterFamilyCompilerVersion( 
+            UINT AdapterFamilyIndex,
+            _Out_  D3D12_VERSION_NUMBER *pCompilerVersion) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetApplicationProfileVersion( 
+            _In_  const D3D12_COMPILER_TARGET *pTarget,
+            _In_  const D3D12_APPLICATION_DESC *pApplicationDesc,
+            _Out_  D3D12_VERSION_NUMBER *pApplicationProfileVersion) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCompilerCacheSession( 
+            _In_reads_(NumPaths)  const D3D12_COMPILER_DATABASE_PATH *pPaths,
+            UINT NumPaths,
+            _In_opt_  const D3D12_COMPILER_TARGET *pTarget,
+            _In_opt_  const D3D12_APPLICATION_DESC *pApplicationDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerCacheSession) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCompiler( 
+            _In_  ID3D12CompilerCacheSession *pCompilerCacheSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompiler) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompilerFactoryVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompilerFactory * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompilerFactory * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompilerFactory * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactory, EnumerateAdapterFamilies)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateAdapterFamilies )( 
+            ID3D12CompilerFactory * This,
+            UINT AdapterFamilyIndex,
+            _Out_  D3D12_ADAPTER_FAMILY *pAdapterFamily);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactory, EnumerateAdapterFamilyABIVersions)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateAdapterFamilyABIVersions )( 
+            ID3D12CompilerFactory * This,
+            UINT AdapterFamilyIndex,
+            _Inout_  UINT32 *pNumABIVersions,
+            _Out_writes_opt_(*pNumABIVersions)  UINT64 *pABIVersions);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactory, EnumerateAdapterFamilyCompilerVersion)
+        HRESULT ( STDMETHODCALLTYPE *EnumerateAdapterFamilyCompilerVersion )( 
+            ID3D12CompilerFactory * This,
+            UINT AdapterFamilyIndex,
+            _Out_  D3D12_VERSION_NUMBER *pCompilerVersion);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactory, GetApplicationProfileVersion)
+        HRESULT ( STDMETHODCALLTYPE *GetApplicationProfileVersion )( 
+            ID3D12CompilerFactory * This,
+            _In_  const D3D12_COMPILER_TARGET *pTarget,
+            _In_  const D3D12_APPLICATION_DESC *pApplicationDesc,
+            _Out_  D3D12_VERSION_NUMBER *pApplicationProfileVersion);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactory, CreateCompilerCacheSession)
+        HRESULT ( STDMETHODCALLTYPE *CreateCompilerCacheSession )( 
+            ID3D12CompilerFactory * This,
+            _In_reads_(NumPaths)  const D3D12_COMPILER_DATABASE_PATH *pPaths,
+            UINT NumPaths,
+            _In_opt_  const D3D12_COMPILER_TARGET *pTarget,
+            _In_opt_  const D3D12_APPLICATION_DESC *pApplicationDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompilerCacheSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompilerFactory, CreateCompiler)
+        HRESULT ( STDMETHODCALLTYPE *CreateCompiler )( 
+            ID3D12CompilerFactory * This,
+            _In_  ID3D12CompilerCacheSession *pCompilerCacheSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCompiler);
+        
+        END_INTERFACE
+    } ID3D12CompilerFactoryVtbl;
+
+    interface ID3D12CompilerFactory
+    {
+        CONST_VTBL struct ID3D12CompilerFactoryVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompilerFactory_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompilerFactory_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompilerFactory_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompilerFactory_EnumerateAdapterFamilies(This,AdapterFamilyIndex,pAdapterFamily)	\
+    ( (This)->lpVtbl -> EnumerateAdapterFamilies(This,AdapterFamilyIndex,pAdapterFamily) ) 
+
+#define ID3D12CompilerFactory_EnumerateAdapterFamilyABIVersions(This,AdapterFamilyIndex,pNumABIVersions,pABIVersions)	\
+    ( (This)->lpVtbl -> EnumerateAdapterFamilyABIVersions(This,AdapterFamilyIndex,pNumABIVersions,pABIVersions) ) 
+
+#define ID3D12CompilerFactory_EnumerateAdapterFamilyCompilerVersion(This,AdapterFamilyIndex,pCompilerVersion)	\
+    ( (This)->lpVtbl -> EnumerateAdapterFamilyCompilerVersion(This,AdapterFamilyIndex,pCompilerVersion) ) 
+
+#define ID3D12CompilerFactory_GetApplicationProfileVersion(This,pTarget,pApplicationDesc,pApplicationProfileVersion)	\
+    ( (This)->lpVtbl -> GetApplicationProfileVersion(This,pTarget,pApplicationDesc,pApplicationProfileVersion) ) 
+
+#define ID3D12CompilerFactory_CreateCompilerCacheSession(This,pPaths,NumPaths,pTarget,pApplicationDesc,riid,ppCompilerCacheSession)	\
+    ( (This)->lpVtbl -> CreateCompilerCacheSession(This,pPaths,NumPaths,pTarget,pApplicationDesc,riid,ppCompilerCacheSession) ) 
+
+#define ID3D12CompilerFactory_CreateCompiler(This,pCompilerCacheSession,riid,ppCompiler)	\
+    ( (This)->lpVtbl -> CreateCompiler(This,pCompilerCacheSession,riid,ppCompiler) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompilerFactory_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compiler_0000_0005 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12CompilerFactoryChild,0xe0d06420,0x9f31,0x47e8,0xae,0x9a,0xdd,0x2b,0xa2,0x5a,0xc0,0xbc);
+DEFINE_GUID(IID_ID3D12CompilerCacheSession,0x5704e5e6,0x054b,0x4738,0xb6,0x61,0x7b,0x0d,0x68,0xd8,0xdd,0xe2);
+DEFINE_GUID(IID_ID3D12CompilerStateObject,0x5981cca4,0xe8ae,0x44ca,0x9b,0x92,0x4f,0xa8,0x6f,0x5a,0x3a,0x3a);
+DEFINE_GUID(IID_ID3D12Compiler,0x8c403c12,0x993b,0x4583,0x80,0xf1,0x68,0x24,0x13,0x8f,0xa6,0x8e);
+DEFINE_GUID(IID_ID3D12CompilerFactory,0xc1ee4b59,0x3f59,0x47a5,0x9b,0x4e,0xa8,0x55,0xc8,0x58,0xa8,0x78);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0005_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compiler_0000_0005_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/directx-headers/include/directx/d3d12sdklayers.h

@@ -171,6 +171,13 @@ typedef interface ID3D12SharingContract ID3D12SharingContract;
 #endif 	/* __ID3D12SharingContract_FWD_DEFINED__ */
 
 
+#ifndef __ID3D12ManualWriteTrackingResource_FWD_DEFINED__
+#define __ID3D12ManualWriteTrackingResource_FWD_DEFINED__
+typedef interface ID3D12ManualWriteTrackingResource ID3D12ManualWriteTrackingResource;
+
+#endif 	/* __ID3D12ManualWriteTrackingResource_FWD_DEFINED__ */
+
+
 #ifndef __ID3D12InfoQueue_FWD_DEFINED__
 #define __ID3D12InfoQueue_FWD_DEFINED__
 typedef interface ID3D12InfoQueue ID3D12InfoQueue;
@@ -199,7 +206,7 @@ extern "C"{
 /* [local] */ 
 
 #include <winapifamily.h>
-//#pragma region App Family
+#pragma region App Family
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
 
 
@@ -992,7 +999,8 @@ enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE
     {
         D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS	= 0,
         D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) ,
-        D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR	= ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) 
+        D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR	= ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) ,
+        D3D12_DEBUG_DEVICE_PARAMETER_BYTECODE_VALIDATION_MODE	= ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR + 1 ) 
     } 	D3D12_DEBUG_DEVICE_PARAMETER_TYPE;
 
 typedef 
@@ -1039,6 +1047,15 @@ typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR
     FLOAT SlowdownFactor;
     } 	D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR;
 
+typedef 
+enum D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE
+    {
+        D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED	= 0,
+        D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED	= ( D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_DISABLED + 1 ) ,
+        D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_ALL_BYTECODE	= ( D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED + 1 ) ,
+        D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE_DEFAULT	= D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_WHEN_HASH_BYPASSED
+    } 	D3D12_DEBUG_DEVICE_BYTECODE_VALIDATION_MODE;
+
 
 
 extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec;
@@ -2237,7 +2254,92 @@ EXTERN_C const IID IID_ID3D12SharingContract;
 #endif 	/* __ID3D12SharingContract_INTERFACE_DEFINED__ */
 
 
-/* interface __MIDL_itf_d3d12sdklayers_0000_0017 */
+#ifndef __ID3D12ManualWriteTrackingResource_INTERFACE_DEFINED__
+#define __ID3D12ManualWriteTrackingResource_INTERFACE_DEFINED__
+
+/* interface ID3D12ManualWriteTrackingResource */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12ManualWriteTrackingResource;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("86ca3b85-49ad-4b6e-aed5-eddb18540f41")
+    ID3D12ManualWriteTrackingResource : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE TrackWrite( 
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pWrittenRange) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ManualWriteTrackingResourceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12ManualWriteTrackingResource * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12ManualWriteTrackingResource * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12ManualWriteTrackingResource * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12ManualWriteTrackingResource, TrackWrite)
+        void ( STDMETHODCALLTYPE *TrackWrite )( 
+            ID3D12ManualWriteTrackingResource * This,
+            UINT Subresource,
+            _In_opt_  const D3D12_RANGE *pWrittenRange);
+        
+        END_INTERFACE
+    } ID3D12ManualWriteTrackingResourceVtbl;
+
+    interface ID3D12ManualWriteTrackingResource
+    {
+        CONST_VTBL struct ID3D12ManualWriteTrackingResourceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12ManualWriteTrackingResource_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12ManualWriteTrackingResource_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12ManualWriteTrackingResource_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12ManualWriteTrackingResource_TrackWrite(This,Subresource,pWrittenRange)	\
+    ( (This)->lpVtbl -> TrackWrite(This,Subresource,pWrittenRange) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12ManualWriteTrackingResource_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0018 */
 /* [local] */ 
 
 typedef 
@@ -2375,6 +2477,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,
@@ -3176,8 +3281,6 @@ enum D3D12_MESSAGE_ID
         D3D12_MESSAGE_ID_UNSUPPORTED_BARRIER_LAYOUT	= 1341,
         D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALID_PARAMETERS	= 1342,
         D3D12_MESSAGE_ID_ENHANCED_BARRIERS_NOT_SUPPORTED	= 1343,
-        D3D12_MESSAGE_ID_CAST_TARGET_TEXEL_SIZE_MISMATCH	= 1344,
-        D3D12_MESSAGE_ID_CAST_TO_PLANAR_NOT_SUPORTED	= 1345,
         D3D12_MESSAGE_ID_LEGACY_BARRIER_VALIDATION_FORCED_ON	= 1346,
         D3D12_MESSAGE_ID_EMPTY_ROOT_DESCRIPTOR_TABLE	= 1347,
         D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ELEMENT_OFFSET_UNALIGNED	= 1348,
@@ -3191,10 +3294,76 @@ enum D3D12_MESSAGE_ID
         D3D12_MESSAGE_ID_NON_OPTIMAL_BARRIER_ONLY_EXECUTE_COMMAND_LISTS	= 1356,
         D3D12_MESSAGE_ID_EXECUTE_INDIRECT_ZERO_COMMAND_COUNT	= 1357,
         D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_TEXTURE_LAYOUT	= 1358,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NOT_SUPPORTED	= 1359,
+        D3D12_MESSAGE_ID_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NOT_SUPPORTED	= 1359,
         D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_TRIANGLE_FANS_NOT_SUPPORTED	= 1360,
         D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED	= 1361,
-        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED + 1 ) 
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDHEAPTYPE	= 1362,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPTYPE	= 1363,
+        D3D12_MESSAGE_ID_DYNAMIC_DEPTH_BIAS_NOT_SUPPORTED	= 1364,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NON_WHOLE_DYNAMIC_DEPTH_BIAS	= 1365,
+        D3D12_MESSAGE_ID_DYNAMIC_DEPTH_BIAS_FLAG_MISSING	= 1366,
+        D3D12_MESSAGE_ID_DYNAMIC_DEPTH_BIAS_NO_PIPELINE	= 1367,
+        D3D12_MESSAGE_ID_DYNAMIC_INDEX_BUFFER_STRIP_CUT_FLAG_MISSING	= 1368,
+        D3D12_MESSAGE_ID_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NO_PIPELINE	= 1369,
+        D3D12_MESSAGE_ID_NONNORMALIZED_COORDINATE_SAMPLING_NOT_SUPPORTED	= 1370,
+        D3D12_MESSAGE_ID_INVALID_CAST_TARGET	= 1371,
+        D3D12_MESSAGE_ID_RENDER_PASS_COMMANDLIST_INVALID_END_STATE	= 1372,
+        D3D12_MESSAGE_ID_RENDER_PASS_COMMANDLIST_INVALID_START_STATE	= 1373,
+        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_ACCESS	= 1374,
+        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_LOCAL_PRESERVE_PARAMETERS	= 1375,
+        D3D12_MESSAGE_ID_RENDER_PASS_LOCAL_PRESERVE_RENDER_PARAMETERS_ERROR	= 1376,
+        D3D12_MESSAGE_ID_RENDER_PASS_LOCAL_DEPTH_STENCIL_ERROR	= 1377,
+        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_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_RENDER_TARGET_OR_DEPTH_STENCIL_RESOUCE_NOT_INITIALIZED	= 1422,
+        D3D12_MESSAGE_ID_BYTECODE_VALIDATION_ERROR	= 1423,
+        D3D12_MESSAGE_ID_FENCE_ZERO_WAIT	= 1424,
+        D3D12_MESSAGE_ID_NON_COMMON_RESOURCE_IN_COPY_QUEUE	= 1431,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MULTIPLE_ROOT_SIGNATURES_DEFINED	= 1435,
+        D3D12_MESSAGE_ID_TEXTURE_BARRIER_INVALID_FLAGS	= 1436,
+        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= 1442
     } 	D3D12_MESSAGE_ID;
 
 typedef struct D3D12_MESSAGE
@@ -3225,8 +3394,8 @@ typedef struct D3D12_INFO_QUEUE_FILTER
 #define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024
 
 
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_s_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_s_ifspec;
 
 #ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__
 #define __ID3D12InfoQueue_INTERFACE_DEFINED__
@@ -3671,7 +3840,7 @@ EXTERN_C const IID IID_ID3D12InfoQueue;
 #endif 	/* __ID3D12InfoQueue_INTERFACE_DEFINED__ */
 
 
-/* interface __MIDL_itf_d3d12sdklayers_0000_0018 */
+/* interface __MIDL_itf_d3d12sdklayers_0000_0019 */
 /* [local] */ 
 
 typedef 
@@ -3691,8 +3860,8 @@ typedef void ( __stdcall *D3D12MessageFunc )(
 
 
 
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_s_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_s_ifspec;
 
 #ifndef __ID3D12InfoQueue1_INTERFACE_DEFINED__
 #define __ID3D12InfoQueue1_INTERFACE_DEFINED__
@@ -3712,7 +3881,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( 
@@ -3914,7 +4083,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)
@@ -4068,11 +4237,11 @@ EXTERN_C const IID IID_ID3D12InfoQueue1;
 #endif 	/* __ID3D12InfoQueue1_INTERFACE_DEFINED__ */
 
 
-/* interface __MIDL_itf_d3d12sdklayers_0000_0019 */
+/* interface __MIDL_itf_d3d12sdklayers_0000_0020 */
 /* [local] */ 
 
 #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
-//#pragma endregion
+#pragma endregion
 DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0);
 DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04);
 DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74);
@@ -4090,12 +4259,13 @@ DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0
 DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e);
 DEFINE_GUID(IID_ID3D12DebugCommandList3,0x197d5e15,0x4d37,0x4d34,0xaf,0x78,0x72,0x4c,0xd7,0x0f,0xdb,0x1f);
 DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef);
+DEFINE_GUID(IID_ID3D12ManualWriteTrackingResource,0x86ca3b85,0x49ad,0x4b6e,0xae,0xd5,0xed,0xdb,0x18,0x54,0x0f,0x41);
 DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58);
 DEFINE_GUID(IID_ID3D12InfoQueue1,0x2852dd88,0xb484,0x4c0c,0xb6,0xb1,0x67,0x16,0x85,0x00,0xe6,0x00);
 
 
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_s_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0020_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0020_v0_0_s_ifspec;
 
 /* Additional Prototypes for ALL interfaces */
 

3rdparty/directx-headers/include/directx/d3d12shader.h

@@ -37,6 +37,8 @@ typedef enum D3D12_SHADER_VERSION_TYPE
     D3D12_SHVER_MESH_SHADER           = 13,
     D3D12_SHVER_AMPLIFICATION_SHADER  = 14,
 
+    D3D12_SHVER_NODE_SHADER           = 15,
+
     D3D12_SHVER_RESERVED0             = 0xFFF0,
 } D3D12_SHADER_VERSION_TYPE;
 
@@ -201,8 +203,10 @@ typedef struct _D3D12_SHADER_INPUT_BIND_DESC
 #define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING                                0x04000000
 #define D3D_SHADER_REQUIRES_WAVE_MMA                                                        0x08000000
 #define D3D_SHADER_REQUIRES_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_REQUIRES_ADVANCED_TEXTURE_OPS                                            0x20000000
+#define D3D_SHADER_REQUIRES_WRITEABLE_MSAA_TEXTURES                                         0x40000000
+#define D3D_SHADER_REQUIRES_SAMPLE_CMP_GRADIENT_OR_BIAS                                     0x80000000
+#define D3D_SHADER_REQUIRES_EXTENDED_COMMAND_INFO                                           0x100000000ull
 
 
 typedef struct _D3D12_LIBRARY_DESC
@@ -488,3 +492,4 @@ extern "C" {
     
 #endif //__D3D12SHADER_H__
 
+

3rdparty/directx-headers/include/directx/d3dcommon.h

@@ -16,7 +16,7 @@
 
 /* verify that the <rpcndr.h> version is high enough to compile this file*/
 #ifndef __REQUIRED_RPCNDR_H_VERSION__
-#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
 #endif
 
 /* verify that the <rpcsal.h> version is high enough to compile this file*/
@@ -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 

3rdparty/directx-headers/include/directx/d3dshadercacheregistration.h

@@ -0,0 +1,998 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * 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 __d3dshadercacheregistration_h__
+#define __d3dshadercacheregistration_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 __ID3DShaderCacheInstallerClient_FWD_DEFINED__
+#define __ID3DShaderCacheInstallerClient_FWD_DEFINED__
+typedef interface ID3DShaderCacheInstallerClient ID3DShaderCacheInstallerClient;
+
+#endif 	/* __ID3DShaderCacheInstallerClient_FWD_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheComponent_FWD_DEFINED__
+#define __ID3DShaderCacheComponent_FWD_DEFINED__
+typedef interface ID3DShaderCacheComponent ID3DShaderCacheComponent;
+
+#endif 	/* __ID3DShaderCacheComponent_FWD_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheApplication_FWD_DEFINED__
+#define __ID3DShaderCacheApplication_FWD_DEFINED__
+typedef interface ID3DShaderCacheApplication ID3DShaderCacheApplication;
+
+#endif 	/* __ID3DShaderCacheApplication_FWD_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheInstaller_FWD_DEFINED__
+#define __ID3DShaderCacheInstaller_FWD_DEFINED__
+typedef interface ID3DShaderCacheInstaller ID3DShaderCacheInstaller;
+
+#endif 	/* __ID3DShaderCacheInstaller_FWD_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheExplorer_FWD_DEFINED__
+#define __ID3DShaderCacheExplorer_FWD_DEFINED__
+typedef interface ID3DShaderCacheExplorer ID3DShaderCacheExplorer;
+
+#endif 	/* __ID3DShaderCacheExplorer_FWD_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheInstallerFactory_FWD_DEFINED__
+#define __ID3DShaderCacheInstallerFactory_FWD_DEFINED__
+typedef interface ID3DShaderCacheInstallerFactory ID3DShaderCacheInstallerFactory;
+
+#endif 	/* __ID3DShaderCacheInstallerFactory_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3dshadercacheregistration_0000_0000 */
+/* [local] */ 
+
+#pragma once
+DEFINE_GUID(CLSID_D3DShaderCacheInstallerFactory,    0x16195a0b, 0x607c, 0x41f1, 0xbf, 0x03, 0xc7, 0x69, 0x4d, 0x60, 0xa8, 0xd4);
+typedef 
+enum D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE
+    {
+        D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE_USER	= 0,
+        D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE_SYSTEM	= ( D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE_USER + 1 ) 
+    } 	D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE;
+
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3DShaderCacheInstallerClient_INTERFACE_DEFINED__
+#define __ID3DShaderCacheInstallerClient_INTERFACE_DEFINED__
+
+/* interface ID3DShaderCacheInstallerClient */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DShaderCacheInstallerClient;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("a16ee930-d9f6-4222-a514-244473e5d266")
+    ID3DShaderCacheInstallerClient
+    {
+    public:
+        BEGIN_INTERFACE
+        virtual HRESULT STDMETHODCALLTYPE GetInstallerName( 
+            _Inout_  SIZE_T *pNameLength,
+            _Out_writes_opt_(*pNameLength)  wchar_t *pName) = 0;
+        
+        virtual D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE STDMETHODCALLTYPE GetInstallerScope( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE HandleDriverUpdate( 
+            _In_  ID3DShaderCacheInstaller *pInstaller) = 0;
+        
+        END_INTERFACE
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DShaderCacheInstallerClientVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerClient, GetInstallerName)
+        HRESULT ( STDMETHODCALLTYPE *GetInstallerName )( 
+            ID3DShaderCacheInstallerClient * This,
+            _Inout_  SIZE_T *pNameLength,
+            _Out_writes_opt_(*pNameLength)  wchar_t *pName);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerClient, GetInstallerScope)
+        D3D_SHADER_CACHE_APP_REGISTRATION_SCOPE ( STDMETHODCALLTYPE *GetInstallerScope )( 
+            ID3DShaderCacheInstallerClient * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerClient, HandleDriverUpdate)
+        HRESULT ( STDMETHODCALLTYPE *HandleDriverUpdate )( 
+            ID3DShaderCacheInstallerClient * This,
+            _In_  ID3DShaderCacheInstaller *pInstaller);
+        
+        END_INTERFACE
+    } ID3DShaderCacheInstallerClientVtbl;
+
+    interface ID3DShaderCacheInstallerClient
+    {
+        CONST_VTBL struct ID3DShaderCacheInstallerClientVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DShaderCacheInstallerClient_GetInstallerName(This,pNameLength,pName)	\
+    ( (This)->lpVtbl -> GetInstallerName(This,pNameLength,pName) ) 
+
+#define ID3DShaderCacheInstallerClient_GetInstallerScope(This)	\
+    ( (This)->lpVtbl -> GetInstallerScope(This) ) 
+
+#define ID3DShaderCacheInstallerClient_HandleDriverUpdate(This,pInstaller)	\
+    ( (This)->lpVtbl -> HandleDriverUpdate(This,pInstaller) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DShaderCacheInstallerClient_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dshadercacheregistration_0000_0001 */
+/* [local] */ 
+
+typedef struct D3D_SHADER_CACHE_PSDB_PROPERTIES
+    {
+    const wchar_t *pAdapterFamily;
+    const wchar_t *pPsdbPath;
+    } 	D3D_SHADER_CACHE_PSDB_PROPERTIES;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3DShaderCacheComponent_INTERFACE_DEFINED__
+#define __ID3DShaderCacheComponent_INTERFACE_DEFINED__
+
+/* interface ID3DShaderCacheComponent */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DShaderCacheComponent;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("eed1bf00-f5c7-4cf7-885c-d0f9c0cb4828")
+    ID3DShaderCacheComponent : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetComponentName( 
+            _Out_  const wchar_t **pName) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetStateObjectDatabasePath( 
+            _Out_  const wchar_t **pPath) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetPrecompiledCachePath( 
+            _In_  const wchar_t *pAdapterFamily,
+            _Inout_  const wchar_t **pPath) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetPrecompiledShaderDatabaseCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetPrecompiledShaderDatabases( 
+            UINT ArraySize,
+            _Out_writes_(ArraySize)  D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DShaderCacheComponentVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DShaderCacheComponent * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DShaderCacheComponent * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DShaderCacheComponent * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetComponentName)
+        HRESULT ( STDMETHODCALLTYPE *GetComponentName )( 
+            ID3DShaderCacheComponent * This,
+            _Out_  const wchar_t **pName);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetStateObjectDatabasePath)
+        HRESULT ( STDMETHODCALLTYPE *GetStateObjectDatabasePath )( 
+            ID3DShaderCacheComponent * This,
+            _Out_  const wchar_t **pPath);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetPrecompiledCachePath)
+        HRESULT ( STDMETHODCALLTYPE *GetPrecompiledCachePath )( 
+            ID3DShaderCacheComponent * This,
+            _In_  const wchar_t *pAdapterFamily,
+            _Inout_  const wchar_t **pPath);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetPrecompiledShaderDatabaseCount)
+        UINT ( STDMETHODCALLTYPE *GetPrecompiledShaderDatabaseCount )( 
+            ID3DShaderCacheComponent * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheComponent, GetPrecompiledShaderDatabases)
+        HRESULT ( STDMETHODCALLTYPE *GetPrecompiledShaderDatabases )( 
+            ID3DShaderCacheComponent * This,
+            UINT ArraySize,
+            _Out_writes_(ArraySize)  D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs);
+        
+        END_INTERFACE
+    } ID3DShaderCacheComponentVtbl;
+
+    interface ID3DShaderCacheComponent
+    {
+        CONST_VTBL struct ID3DShaderCacheComponentVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DShaderCacheComponent_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DShaderCacheComponent_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DShaderCacheComponent_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DShaderCacheComponent_GetComponentName(This,pName)	\
+    ( (This)->lpVtbl -> GetComponentName(This,pName) ) 
+
+#define ID3DShaderCacheComponent_GetStateObjectDatabasePath(This,pPath)	\
+    ( (This)->lpVtbl -> GetStateObjectDatabasePath(This,pPath) ) 
+
+#define ID3DShaderCacheComponent_GetPrecompiledCachePath(This,pAdapterFamily,pPath)	\
+    ( (This)->lpVtbl -> GetPrecompiledCachePath(This,pAdapterFamily,pPath) ) 
+
+#define ID3DShaderCacheComponent_GetPrecompiledShaderDatabaseCount(This)	\
+    ( (This)->lpVtbl -> GetPrecompiledShaderDatabaseCount(This) ) 
+
+#define ID3DShaderCacheComponent_GetPrecompiledShaderDatabases(This,ArraySize,pPSDBs)	\
+    ( (This)->lpVtbl -> GetPrecompiledShaderDatabases(This,ArraySize,pPSDBs) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DShaderCacheComponent_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dshadercacheregistration_0000_0002 */
+/* [local] */ 
+
+typedef 
+enum D3D_SHADER_CACHE_TARGET_FLAGS
+    {
+        D3D_SHADER_CACHE_TARGET_FLAG_NONE	= 0
+    } 	D3D_SHADER_CACHE_TARGET_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D_SHADER_CACHE_TARGET_FLAGS )
+typedef union D3D_VERSION_NUMBER
+    {
+    UINT64 Version;
+    UINT16 VersionParts[ 4 ];
+    } 	D3D_VERSION_NUMBER;
+
+typedef struct D3D_SHADER_CACHE_COMPILER_PROPERTIES
+    {
+    wchar_t szAdapterFamily[ 128 ];
+    UINT64 MinimumABISupportVersion;
+    UINT64 MaximumABISupportVersion;
+    D3D_VERSION_NUMBER CompilerVersion;
+    D3D_VERSION_NUMBER ApplicationProfileVersion;
+    } 	D3D_SHADER_CACHE_COMPILER_PROPERTIES;
+
+typedef struct D3D_SHADER_CACHE_APPLICATION_DESC
+    {
+    const wchar_t *pExeFilename;
+    const wchar_t *pName;
+    D3D_VERSION_NUMBER Version;
+    const wchar_t *pEngineName;
+    D3D_VERSION_NUMBER EngineVersion;
+    } 	D3D_SHADER_CACHE_APPLICATION_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0002_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0002_v0_0_s_ifspec;
+
+#ifndef __ID3DShaderCacheApplication_INTERFACE_DEFINED__
+#define __ID3DShaderCacheApplication_INTERFACE_DEFINED__
+
+/* interface ID3DShaderCacheApplication */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DShaderCacheApplication;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fc688ee2-1b35-4913-93be-1ca3fa7df39e")
+    ID3DShaderCacheApplication : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetExePath( 
+            _Out_  const wchar_t **pExePath) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDesc( 
+            _Out_  D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RegisterComponent( 
+            _In_  const wchar_t *pName,
+            _In_  const wchar_t *pStateObjectDBPath,
+            _In_  UINT NumPSDB,
+            _In_reads_(NumPSDB)  const D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs,
+            REFIID riid,
+            _COM_Outptr_  void **ppvComponent) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RemoveComponent( 
+            _In_  ID3DShaderCacheComponent *pComponent) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetComponentCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetComponent( 
+            _In_  UINT index,
+            REFIID riid,
+            _COM_Outptr_  void **ppvComponent) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetPrecompileTargetCount( 
+            D3D_SHADER_CACHE_TARGET_FLAGS flags) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetPrecompileTargets( 
+            _In_  UINT ArraySize,
+            _In_reads_(ArraySize)  D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray,
+            D3D_SHADER_CACHE_TARGET_FLAGS flags) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetInstallerName( 
+            _Out_  const wchar_t **pInstallerName) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DShaderCacheApplicationVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DShaderCacheApplication * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DShaderCacheApplication * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DShaderCacheApplication * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetExePath)
+        HRESULT ( STDMETHODCALLTYPE *GetExePath )( 
+            ID3DShaderCacheApplication * This,
+            _Out_  const wchar_t **pExePath);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetDesc)
+        HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3DShaderCacheApplication * This,
+            _Out_  D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, RegisterComponent)
+        HRESULT ( STDMETHODCALLTYPE *RegisterComponent )( 
+            ID3DShaderCacheApplication * This,
+            _In_  const wchar_t *pName,
+            _In_  const wchar_t *pStateObjectDBPath,
+            _In_  UINT NumPSDB,
+            _In_reads_(NumPSDB)  const D3D_SHADER_CACHE_PSDB_PROPERTIES *pPSDBs,
+            REFIID riid,
+            _COM_Outptr_  void **ppvComponent);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, RemoveComponent)
+        HRESULT ( STDMETHODCALLTYPE *RemoveComponent )( 
+            ID3DShaderCacheApplication * This,
+            _In_  ID3DShaderCacheComponent *pComponent);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetComponentCount)
+        UINT ( STDMETHODCALLTYPE *GetComponentCount )( 
+            ID3DShaderCacheApplication * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetComponent)
+        HRESULT ( STDMETHODCALLTYPE *GetComponent )( 
+            ID3DShaderCacheApplication * This,
+            _In_  UINT index,
+            REFIID riid,
+            _COM_Outptr_  void **ppvComponent);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetPrecompileTargetCount)
+        UINT ( STDMETHODCALLTYPE *GetPrecompileTargetCount )( 
+            ID3DShaderCacheApplication * This,
+            D3D_SHADER_CACHE_TARGET_FLAGS flags);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetPrecompileTargets)
+        HRESULT ( STDMETHODCALLTYPE *GetPrecompileTargets )( 
+            ID3DShaderCacheApplication * This,
+            _In_  UINT ArraySize,
+            _In_reads_(ArraySize)  D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray,
+            D3D_SHADER_CACHE_TARGET_FLAGS flags);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheApplication, GetInstallerName)
+        HRESULT ( STDMETHODCALLTYPE *GetInstallerName )( 
+            ID3DShaderCacheApplication * This,
+            _Out_  const wchar_t **pInstallerName);
+        
+        END_INTERFACE
+    } ID3DShaderCacheApplicationVtbl;
+
+    interface ID3DShaderCacheApplication
+    {
+        CONST_VTBL struct ID3DShaderCacheApplicationVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DShaderCacheApplication_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DShaderCacheApplication_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DShaderCacheApplication_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DShaderCacheApplication_GetExePath(This,pExePath)	\
+    ( (This)->lpVtbl -> GetExePath(This,pExePath) ) 
+
+#define ID3DShaderCacheApplication_GetDesc(This,pApplicationDesc)	\
+    ( (This)->lpVtbl -> GetDesc(This,pApplicationDesc) ) 
+
+#define ID3DShaderCacheApplication_RegisterComponent(This,pName,pStateObjectDBPath,NumPSDB,pPSDBs,riid,ppvComponent)	\
+    ( (This)->lpVtbl -> RegisterComponent(This,pName,pStateObjectDBPath,NumPSDB,pPSDBs,riid,ppvComponent) ) 
+
+#define ID3DShaderCacheApplication_RemoveComponent(This,pComponent)	\
+    ( (This)->lpVtbl -> RemoveComponent(This,pComponent) ) 
+
+#define ID3DShaderCacheApplication_GetComponentCount(This)	\
+    ( (This)->lpVtbl -> GetComponentCount(This) ) 
+
+#define ID3DShaderCacheApplication_GetComponent(This,index,riid,ppvComponent)	\
+    ( (This)->lpVtbl -> GetComponent(This,index,riid,ppvComponent) ) 
+
+#define ID3DShaderCacheApplication_GetPrecompileTargetCount(This,flags)	\
+    ( (This)->lpVtbl -> GetPrecompileTargetCount(This,flags) ) 
+
+#define ID3DShaderCacheApplication_GetPrecompileTargets(This,ArraySize,pArray,flags)	\
+    ( (This)->lpVtbl -> GetPrecompileTargets(This,ArraySize,pArray,flags) ) 
+
+#define ID3DShaderCacheApplication_GetInstallerName(This,pInstallerName)	\
+    ( (This)->lpVtbl -> GetInstallerName(This,pInstallerName) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DShaderCacheApplication_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dshadercacheregistration_0000_0003 */
+/* [local] */ 
+
+typedef struct SC_HANDLE__ *SC_HANDLE;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0003_v0_0_s_ifspec;
+
+#ifndef __ID3DShaderCacheInstaller_INTERFACE_DEFINED__
+#define __ID3DShaderCacheInstaller_INTERFACE_DEFINED__
+
+/* interface ID3DShaderCacheInstaller */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DShaderCacheInstaller;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("bbe30de1-6318-4526-ae17-776693191bb4")
+    ID3DShaderCacheInstaller : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RegisterDriverUpdateListener( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnregisterDriverUpdateListener( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RegisterServiceDriverUpdateTrigger( 
+            SC_HANDLE hServiceHandle) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnregisterServiceDriverUpdateTrigger( 
+            SC_HANDLE hServiceHandle) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RegisterApplication( 
+            _In_  const wchar_t *pExePath,
+            _In_  const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvApp) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE RemoveApplication( 
+            _In_  ID3DShaderCacheApplication *pApplication) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetApplicationCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetApplication( 
+            _In_  UINT index,
+            REFIID riid,
+            _COM_Outptr_  void **ppvApp) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ClearAllState( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetMaxPrecompileTargetCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetPrecompileTargets( 
+            _In_opt_  const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc,
+            _Inout_  UINT *pArraySize,
+            _Out_writes_(*pArraySize)  D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray,
+            D3D_SHADER_CACHE_TARGET_FLAGS flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DShaderCacheInstallerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DShaderCacheInstaller * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RegisterDriverUpdateListener)
+        HRESULT ( STDMETHODCALLTYPE *RegisterDriverUpdateListener )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, UnregisterDriverUpdateListener)
+        HRESULT ( STDMETHODCALLTYPE *UnregisterDriverUpdateListener )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RegisterServiceDriverUpdateTrigger)
+        HRESULT ( STDMETHODCALLTYPE *RegisterServiceDriverUpdateTrigger )( 
+            ID3DShaderCacheInstaller * This,
+            SC_HANDLE hServiceHandle);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, UnregisterServiceDriverUpdateTrigger)
+        HRESULT ( STDMETHODCALLTYPE *UnregisterServiceDriverUpdateTrigger )( 
+            ID3DShaderCacheInstaller * This,
+            SC_HANDLE hServiceHandle);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RegisterApplication)
+        HRESULT ( STDMETHODCALLTYPE *RegisterApplication )( 
+            ID3DShaderCacheInstaller * This,
+            _In_  const wchar_t *pExePath,
+            _In_  const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppvApp);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, RemoveApplication)
+        HRESULT ( STDMETHODCALLTYPE *RemoveApplication )( 
+            ID3DShaderCacheInstaller * This,
+            _In_  ID3DShaderCacheApplication *pApplication);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetApplicationCount)
+        UINT ( STDMETHODCALLTYPE *GetApplicationCount )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetApplication)
+        HRESULT ( STDMETHODCALLTYPE *GetApplication )( 
+            ID3DShaderCacheInstaller * This,
+            _In_  UINT index,
+            REFIID riid,
+            _COM_Outptr_  void **ppvApp);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, ClearAllState)
+        HRESULT ( STDMETHODCALLTYPE *ClearAllState )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetMaxPrecompileTargetCount)
+        UINT ( STDMETHODCALLTYPE *GetMaxPrecompileTargetCount )( 
+            ID3DShaderCacheInstaller * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstaller, GetPrecompileTargets)
+        HRESULT ( STDMETHODCALLTYPE *GetPrecompileTargets )( 
+            ID3DShaderCacheInstaller * This,
+            _In_opt_  const D3D_SHADER_CACHE_APPLICATION_DESC *pApplicationDesc,
+            _Inout_  UINT *pArraySize,
+            _Out_writes_(*pArraySize)  D3D_SHADER_CACHE_COMPILER_PROPERTIES *pArray,
+            D3D_SHADER_CACHE_TARGET_FLAGS flags);
+        
+        END_INTERFACE
+    } ID3DShaderCacheInstallerVtbl;
+
+    interface ID3DShaderCacheInstaller
+    {
+        CONST_VTBL struct ID3DShaderCacheInstallerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DShaderCacheInstaller_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DShaderCacheInstaller_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DShaderCacheInstaller_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DShaderCacheInstaller_RegisterDriverUpdateListener(This)	\
+    ( (This)->lpVtbl -> RegisterDriverUpdateListener(This) ) 
+
+#define ID3DShaderCacheInstaller_UnregisterDriverUpdateListener(This)	\
+    ( (This)->lpVtbl -> UnregisterDriverUpdateListener(This) ) 
+
+#define ID3DShaderCacheInstaller_RegisterServiceDriverUpdateTrigger(This,hServiceHandle)	\
+    ( (This)->lpVtbl -> RegisterServiceDriverUpdateTrigger(This,hServiceHandle) ) 
+
+#define ID3DShaderCacheInstaller_UnregisterServiceDriverUpdateTrigger(This,hServiceHandle)	\
+    ( (This)->lpVtbl -> UnregisterServiceDriverUpdateTrigger(This,hServiceHandle) ) 
+
+#define ID3DShaderCacheInstaller_RegisterApplication(This,pExePath,pApplicationDesc,riid,ppvApp)	\
+    ( (This)->lpVtbl -> RegisterApplication(This,pExePath,pApplicationDesc,riid,ppvApp) ) 
+
+#define ID3DShaderCacheInstaller_RemoveApplication(This,pApplication)	\
+    ( (This)->lpVtbl -> RemoveApplication(This,pApplication) ) 
+
+#define ID3DShaderCacheInstaller_GetApplicationCount(This)	\
+    ( (This)->lpVtbl -> GetApplicationCount(This) ) 
+
+#define ID3DShaderCacheInstaller_GetApplication(This,index,riid,ppvApp)	\
+    ( (This)->lpVtbl -> GetApplication(This,index,riid,ppvApp) ) 
+
+#define ID3DShaderCacheInstaller_ClearAllState(This)	\
+    ( (This)->lpVtbl -> ClearAllState(This) ) 
+
+#define ID3DShaderCacheInstaller_GetMaxPrecompileTargetCount(This)	\
+    ( (This)->lpVtbl -> GetMaxPrecompileTargetCount(This) ) 
+
+#define ID3DShaderCacheInstaller_GetPrecompileTargets(This,pApplicationDesc,pArraySize,pArray,flags)	\
+    ( (This)->lpVtbl -> GetPrecompileTargets(This,pApplicationDesc,pArraySize,pArray,flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DShaderCacheInstaller_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheExplorer_INTERFACE_DEFINED__
+#define __ID3DShaderCacheExplorer_INTERFACE_DEFINED__
+
+/* interface ID3DShaderCacheExplorer */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DShaderCacheExplorer;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("90432322-32f5-487f-9264-e9390fa58b2a")
+    ID3DShaderCacheExplorer : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetApplicationFromExePath( 
+            _In_  const wchar_t *pFullExePath,
+            REFIID riid,
+            _COM_Outptr_  void **ppvApp) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DShaderCacheExplorerVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DShaderCacheExplorer * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DShaderCacheExplorer * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DShaderCacheExplorer * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheExplorer, GetApplicationFromExePath)
+        HRESULT ( STDMETHODCALLTYPE *GetApplicationFromExePath )( 
+            ID3DShaderCacheExplorer * This,
+            _In_  const wchar_t *pFullExePath,
+            REFIID riid,
+            _COM_Outptr_  void **ppvApp);
+        
+        END_INTERFACE
+    } ID3DShaderCacheExplorerVtbl;
+
+    interface ID3DShaderCacheExplorer
+    {
+        CONST_VTBL struct ID3DShaderCacheExplorerVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DShaderCacheExplorer_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DShaderCacheExplorer_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DShaderCacheExplorer_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DShaderCacheExplorer_GetApplicationFromExePath(This,pFullExePath,riid,ppvApp)	\
+    ( (This)->lpVtbl -> GetApplicationFromExePath(This,pFullExePath,riid,ppvApp) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DShaderCacheExplorer_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3DShaderCacheInstallerFactory_INTERFACE_DEFINED__
+#define __ID3DShaderCacheInstallerFactory_INTERFACE_DEFINED__
+
+/* interface ID3DShaderCacheInstallerFactory */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DShaderCacheInstallerFactory;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("09b2dfe4-840f-401a-804c-0dd8aadc9e9f")
+    ID3DShaderCacheInstallerFactory : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateInstaller( 
+            _In_  ID3DShaderCacheInstallerClient *pClient,
+            REFIID riid,
+            _COM_Outptr_  void **ppvInstaller) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateExplorer( 
+            IUnknown *pUnknown,
+            REFIID riid,
+            _COM_Outptr_  void **ppvExplorer) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DShaderCacheInstallerFactoryVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DShaderCacheInstallerFactory * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DShaderCacheInstallerFactory * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DShaderCacheInstallerFactory * This);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerFactory, CreateInstaller)
+        HRESULT ( STDMETHODCALLTYPE *CreateInstaller )( 
+            ID3DShaderCacheInstallerFactory * This,
+            _In_  ID3DShaderCacheInstallerClient *pClient,
+            REFIID riid,
+            _COM_Outptr_  void **ppvInstaller);
+        
+        DECLSPEC_XFGVIRT(ID3DShaderCacheInstallerFactory, CreateExplorer)
+        HRESULT ( STDMETHODCALLTYPE *CreateExplorer )( 
+            ID3DShaderCacheInstallerFactory * This,
+            IUnknown *pUnknown,
+            REFIID riid,
+            _COM_Outptr_  void **ppvExplorer);
+        
+        END_INTERFACE
+    } ID3DShaderCacheInstallerFactoryVtbl;
+
+    interface ID3DShaderCacheInstallerFactory
+    {
+        CONST_VTBL struct ID3DShaderCacheInstallerFactoryVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DShaderCacheInstallerFactory_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DShaderCacheInstallerFactory_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DShaderCacheInstallerFactory_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DShaderCacheInstallerFactory_CreateInstaller(This,pClient,riid,ppvInstaller)	\
+    ( (This)->lpVtbl -> CreateInstaller(This,pClient,riid,ppvInstaller) ) 
+
+#define ID3DShaderCacheInstallerFactory_CreateExplorer(This,pUnknown,riid,ppvExplorer)	\
+    ( (This)->lpVtbl -> CreateExplorer(This,pUnknown,riid,ppvExplorer) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DShaderCacheInstallerFactory_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dshadercacheregistration_0000_0006 */
+/* [local] */ 
+
+DEFINE_GUID(IID_ID3DShaderCacheInstallerClient,0xa16ee930,0xd9f6,0x4222,0xa5,0x14,0x24,0x44,0x73,0xe5,0xd2,0x66);
+DEFINE_GUID(IID_ID3DShaderCacheComponent,0xeed1bf00,0xf5c7,0x4cf7,0x88,0x5c,0xd0,0xf9,0xc0,0xcb,0x48,0x28);
+DEFINE_GUID(IID_ID3DShaderCacheApplication,0xfc688ee2,0x1b35,0x4913,0x93,0xbe,0x1c,0xa3,0xfa,0x7d,0xf3,0x9e);
+DEFINE_GUID(IID_ID3DShaderCacheInstaller,0xbbe30de1,0x6318,0x4526,0xae,0x17,0x77,0x66,0x93,0x19,0x1b,0xb4);
+DEFINE_GUID(IID_ID3DShaderCacheExplorer,0x90432322,0x32f5,0x487f,0x92,0x64,0xe9,0x39,0x0f,0xa5,0x8b,0x2a);
+DEFINE_GUID(IID_ID3DShaderCacheInstallerFactory,0x09b2dfe4,0x840f,0x401a,0x80,0x4c,0x0d,0xd8,0xaa,0xdc,0x9e,0x9f);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0006_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dshadercacheregistration_0000_0006_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/directx-headers/include/directx/dxcore_interface.h

@@ -35,13 +35,25 @@ enum class DXCoreAdapterProperty : uint32_t
     IsHardware = 11,
     IsIntegrated = 12,
     IsDetachable = 13,
-    HardwareIDParts = 14
+    HardwareIDParts = 14,
+    PhysicalAdapterCount = 15,
+    AdapterEngineCount = 16,
+    AdapterEngineName = 17,
 };
 
 enum class DXCoreAdapterState : uint32_t
 {
     IsDriverUpdateInProgress = 0,
-    AdapterMemoryBudget = 1
+    AdapterMemoryBudget = 1,
+    AdapterMemoryUsageBytes = 2,
+    AdapterMemoryUsageByProcessBytes = 3,
+    AdapterEngineRunningTimeMicroseconds = 4,
+    AdapterEngineRunningTimeByProcessMicroseconds = 5,
+    AdapterTemperatureCelsius = 6,
+    AdapterInUseProcessCount = 7,
+    AdapterInUseProcessSet = 8,
+    AdapterEngineFrequencyHertz = 9,
+    AdapterMemoryFrequencyHertz = 10
 };
 
 enum class DXCoreSegmentGroup : uint32_t
@@ -65,6 +77,34 @@ enum class DXCoreAdapterPreference : uint32_t
     HighPerformance = 2
 };
 
+enum class DXCoreWorkload : uint32_t
+{
+    Graphics = 0,
+    Compute = 1,
+    Media = 2,
+    MachineLearning = 3,
+};
+
+enum class DXCoreRuntimeFilterFlags : uint32_t
+{
+    None = 0x0,
+    D3D11 = 0x1,
+    D3D12 = 0x2
+};
+
+DEFINE_ENUM_FLAG_OPERATORS(DXCoreRuntimeFilterFlags)
+
+enum class DXCoreHardwareTypeFilterFlags : uint32_t
+{
+    None = 0x0,
+    GPU = 0x1,
+    ComputeAccelerator = 0x2,
+    NPU = 0x4,
+    MediaAccelerator = 0x8
+};
+
+DEFINE_ENUM_FLAG_OPERATORS(DXCoreHardwareTypeFilterFlags)
+
 struct DXCoreHardwareID
 {
     uint32_t vendorID;
@@ -96,6 +136,86 @@ struct DXCoreAdapterMemoryBudget
     uint64_t currentReservation;
 };
 
+struct DXCoreAdapterEngineIndex
+{
+    uint32_t physicalAdapterIndex;
+    uint32_t engineIndex;
+};
+
+struct DXCoreEngineQueryInput
+{
+    DXCoreAdapterEngineIndex adapterEngineIndex;
+    uint32_t processId;
+};
+
+struct DXCoreEngineQueryOutput
+{
+    uint64_t runningTime;
+    bool processQuerySucceeded;
+};
+
+enum class DXCoreMemoryType : uint32_t
+{
+    Dedicated = 0,
+    Shared = 1
+};
+
+struct DXCoreMemoryUsage
+{
+    uint64_t committed;
+    uint64_t resident;
+};
+
+struct DXCoreMemoryQueryInput
+{
+    uint32_t physicalAdapterIndex;
+    DXCoreMemoryType memoryType;
+};
+
+struct DXCoreProcessMemoryQueryInput
+{
+    uint32_t physicalAdapterIndex;
+    DXCoreMemoryType memoryType;
+    uint32_t processId;
+};
+
+struct DXCoreProcessMemoryQueryOutput
+{
+    DXCoreMemoryUsage memoryUsage;
+    bool processQuerySucceeded;
+};
+
+struct DXCoreAdapterProcessSetQueryInput
+{
+    uint32_t arraySize;
+    _Field_size_(arraySize) uint32_t* processIds;
+};
+
+struct DXCoreAdapterProcessSetQueryOutput
+{
+    uint32_t processesWritten;
+    uint32_t processesTotal;
+};
+
+struct DXCoreEngineNamePropertyInput
+{
+    DXCoreAdapterEngineIndex adapterEngineIndex;
+    uint32_t engineNameLength;
+    _Field_size_(engineNameLength) wchar_t *engineName;
+};
+
+struct DXCoreEngineNamePropertyOutput
+{
+    uint32_t engineNameLength;
+};
+
+struct DXCoreFrequencyQueryOutput
+{
+    uint64_t frequency;
+    uint64_t maxFrequency;
+    uint64_t maxOverclockedFrequency;
+};
+
 typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)(
     DXCoreNotificationType notificationType,
     _In_ IUnknown *object,
@@ -104,11 +224,21 @@ typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)(
 static_assert(sizeof(bool) == 1, "bool assumed as one byte");
 
 DEFINE_GUID(IID_IDXCoreAdapterFactory, 0x78ee5945, 0xc36e, 0x4b13, 0xa6, 0x69, 0x00, 0x5d, 0xd1, 0x1c, 0x0f, 0x06);
+DEFINE_GUID(IID_IDXCoreAdapterFactory1, 0xd5682e19, 0x6d21, 0x401c, 0x82, 0x7a, 0x9a, 0x51, 0xa4, 0xea, 0x35, 0xd7);
 DEFINE_GUID(IID_IDXCoreAdapterList, 0x526c7776, 0x40e9, 0x459b, 0xb7, 0x11, 0xf3, 0x2a, 0xd7, 0x6d, 0xfc, 0x28);
 DEFINE_GUID(IID_IDXCoreAdapter, 0xf0db4c7f, 0xfe5a, 0x42a2, 0xbd, 0x62, 0xf2, 0xa6, 0xcf, 0x6f, 0xc8, 0x3e);
+DEFINE_GUID(IID_IDXCoreAdapter1, 0xa0783366, 0xcfa3, 0x43be, 0x9d, 0x79, 0x55, 0xb2, 0xda, 0x97, 0xc6, 0x3c);
+
 DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D11_GRAPHICS, 0x8c47866b, 0x7583, 0x450d, 0xf0, 0xf0, 0x6b, 0xad, 0xa8, 0x95, 0xaf, 0x4b);
 DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GRAPHICS, 0x0c9ece4d, 0x2f6e, 0x4f01, 0x8c, 0x96, 0xe8, 0x9e, 0x33, 0x1b, 0x47, 0xb1);
 DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE, 0x248e2800, 0xa793, 0x4724, 0xab, 0xaa, 0x23, 0xa6, 0xde, 0x1b, 0xe0, 0x90);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GENERIC_ML, 0xb71b0d41, 0x1088, 0x422f, 0xa2, 0x7c, 0x2, 0x50, 0xb7, 0xd3, 0xa9, 0x88);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GENERIC_MEDIA, 0x8eb2c848, 0x82f6, 0x4b49, 0xaa, 0x87, 0xae, 0xcf, 0xcf, 0x1, 0x74, 0xc6);
+
+DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_GPU, 0xb69eb219, 0x3ded, 0x4464, 0x97, 0x9f, 0xa0, 0xb, 0xd4, 0x68, 0x70, 0x6);
+DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_COMPUTE_ACCELERATOR, 0xe0b195da, 0x58ef, 0x4a22, 0x90, 0xf1, 0x1f, 0x28, 0x16, 0x9c, 0xab, 0x8d);
+DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_NPU, 0xd46140c4, 0xadd7, 0x451b, 0x9e, 0x56, 0x6, 0xfe, 0x8c, 0x3b, 0x58, 0xed);
+DEFINE_GUID(DXCORE_HARDWARE_TYPE_ATTRIBUTE_MEDIA_ACCELERATOR, 0x66bdb96a, 0x50b, 0x44c7, 0xa4, 0xfd, 0xd1, 0x44, 0xce, 0xa, 0xb4, 0x43);
 
 /* interface IDXCoreAdapter */
 MIDL_INTERFACE("f0db4c7f-fe5a-42a2-bd62-f2a6cf6fc83e")
@@ -214,6 +344,32 @@ public:
     }
 };
 
+/* interface IDXCoreAdapter1 */
+MIDL_INTERFACE("a0783366-cfa3-43be-9d79-55b2da97c63c")
+IDXCoreAdapter1 : public IDXCoreAdapter
+{
+public:
+    virtual HRESULT STDMETHODCALLTYPE GetPropertyWithInput(
+        DXCoreAdapterProperty property,
+        size_t inputPropertyDetailsSize,
+        _In_reads_bytes_opt_(inputPropertyDetailsSize) const void *inputPropertyDetails,
+        size_t outputBufferSize,
+        _Out_writes_bytes_(outputBufferSize) void *outputBuffer) = 0;
+
+    template <class T1, class T2>
+    HRESULT GetPropertyWithInput(
+            DXCoreAdapterProperty property,
+            _In_reads_bytes_opt_(sizeof(T1)) const T1 *inputPropertyDetails,
+            _Out_writes_bytes_(sizeof(T2)) T2 *outputBuffer)
+        {
+            return GetPropertyWithInput(property,
+                                        sizeof(T1),
+                                        (const void*)inputPropertyDetails,
+                                        sizeof(T2),
+                                        (void*)outputBuffer);
+        }
+};
+
 /* interface IDXCoreAdapterList */
 MIDL_INTERFACE("526c7776-40e9-459b-b711-f32ad76dfc28")
 IDXCoreAdapterList : public IUnknown
@@ -309,8 +465,33 @@ public:
         uint32_t eventCookie) = 0;
 };
 
+/* interface IDXCoreAdapterFactory1 */
+MIDL_INTERFACE("d5682e19-6d21-401c-827a-9a51a4ea35d7")
+IDXCoreAdapterFactory1 : public IDXCoreAdapterFactory
+{
+public:
+    virtual HRESULT STDMETHODCALLTYPE CreateAdapterListByWorkload(
+        DXCoreWorkload workload,
+        DXCoreRuntimeFilterFlags runtimeFilter,
+        DXCoreHardwareTypeFilterFlags hardwareTypeFilter,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapterList) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE CreateAdapterListByWorkload(
+        DXCoreWorkload workload,
+        DXCoreRuntimeFilterFlags runtimeFilter,
+        DXCoreHardwareTypeFilterFlags hardwareTypeFilter,
+        _COM_Outptr_ T **ppvAdapterList)
+    {
+        return CreateAdapterListByWorkload(workload,
+                                           runtimeFilter,
+                                           hardwareTypeFilter,
+                                           IID_PPV_ARGS(ppvAdapterList));
+    }
+};
+
 #endif // __cplusplus
 
 #endif // __dxcore_interface_h__
 
-

3rdparty/directx-headers/include/directx/dxgi1_4.h

@@ -3,14 +3,14 @@
 /* this ALWAYS GENERATED file contains the definitions for the interfaces */
 
 
- /* File created by MIDL compiler version 8.01.0622 */
+ /* File created by MIDL compiler version 8.01.0628 */
 /* @@MIDL_FILE_HEADING(  ) */
 
 
 
 /* verify that the <rpcndr.h> version is high enough to compile this file*/
 #ifndef __REQUIRED_RPCNDR_H_VERSION__
-#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#define __REQUIRED_RPCNDR_H_VERSION__ 501
 #endif
 
 /* verify that the <rpcsal.h> version is high enough to compile this file*/
@@ -37,6 +37,14 @@
 #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 __IDXGISwapChain3_FWD_DEFINED__
@@ -78,6 +86,9 @@ extern "C"{
 /* interface __MIDL_itf_dxgi1_4_0000_0000 */
 /* [local] */ 
 
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
 typedef 
 enum DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG
     {
@@ -142,18 +153,22 @@ EXTERN_C const IID IID_IDXGISwapChain3;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGISwapChain3 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGISwapChain3 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGISwapChain3 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -162,6 +177,7 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -169,6 +185,7 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -178,6 +195,7 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -185,6 +203,7 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice)
         HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -192,11 +211,13 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppDevice);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, Present)
         HRESULT ( STDMETHODCALLTYPE *Present )( 
             IDXGISwapChain3 * This,
             /* [in] */ UINT SyncInterval,
             /* [in] */ UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer)
         HRESULT ( STDMETHODCALLTYPE *GetBuffer )( 
             IDXGISwapChain3 * This,
             /* [in] */ UINT Buffer,
@@ -205,12 +226,14 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][out][in] */ 
             _COM_Outptr_  void **ppSurface);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState)
         HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( 
             IDXGISwapChain3 * This,
             /* [in] */ BOOL Fullscreen,
             /* [annotation][in] */ 
             _In_opt_  IDXGIOutput *pTarget);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState)
         HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
@@ -218,11 +241,13 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][out] */ 
             _COM_Outptr_opt_result_maybenull_  IDXGIOutput **ppTarget);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_SWAP_CHAIN_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers)
         HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( 
             IDXGISwapChain3 * This,
             /* [in] */ UINT BufferCount,
@@ -231,41 +256,49 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [in] */ DXGI_FORMAT NewFormat,
             /* [in] */ UINT SwapChainFlags);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget)
         HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_MODE_DESC *pNewTargetParameters);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput)
         HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIOutput **ppOutput);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics)
         HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_FRAME_STATISTICS *pStats);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount)
         HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  UINT *pLastPresentCount);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetDesc1)
         HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_SWAP_CHAIN_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetFullscreenDesc)
         HRESULT ( STDMETHODCALLTYPE *GetFullscreenDesc )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetHwnd)
         HRESULT ( STDMETHODCALLTYPE *GetHwnd )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  HWND *pHwnd);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetCoreWindow)
         HRESULT ( STDMETHODCALLTYPE *GetCoreWindow )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -273,6 +306,7 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][out] */ 
             _COM_Outptr_  void **ppUnk);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, Present1)
         HRESULT ( STDMETHODCALLTYPE *Present1 )( 
             IDXGISwapChain3 * This,
             /* [in] */ UINT SyncInterval,
@@ -280,39 +314,47 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][in] */ 
             _In_  const DXGI_PRESENT_PARAMETERS *pPresentParameters);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, IsTemporaryMonoSupported)
         BOOL ( STDMETHODCALLTYPE *IsTemporaryMonoSupported )( 
             IDXGISwapChain3 * This);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRestrictToOutput)
         HRESULT ( STDMETHODCALLTYPE *GetRestrictToOutput )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  IDXGIOutput **ppRestrictToOutput);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, SetBackgroundColor)
         HRESULT ( STDMETHODCALLTYPE *SetBackgroundColor )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_RGBA *pColor);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetBackgroundColor)
         HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_RGBA *pColor);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, SetRotation)
         HRESULT ( STDMETHODCALLTYPE *SetRotation )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
             _In_  DXGI_MODE_ROTATION Rotation);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRotation)
         HRESULT ( STDMETHODCALLTYPE *GetRotation )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_MODE_ROTATION *pRotation);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, SetSourceSize)
         HRESULT ( STDMETHODCALLTYPE *SetSourceSize )( 
             IDXGISwapChain3 * This,
             UINT Width,
             UINT Height);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetSourceSize)
         HRESULT ( STDMETHODCALLTYPE *GetSourceSize )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
@@ -320,30 +362,37 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][out] */ 
             _Out_  UINT *pHeight);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMaximumFrameLatency)
         HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( 
             IDXGISwapChain3 * This,
             UINT MaxLatency);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMaximumFrameLatency)
         HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  UINT *pMaxLatency);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetFrameLatencyWaitableObject)
         HANDLE ( STDMETHODCALLTYPE *GetFrameLatencyWaitableObject )( 
             IDXGISwapChain3 * This);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMatrixTransform)
         HRESULT ( STDMETHODCALLTYPE *SetMatrixTransform )( 
             IDXGISwapChain3 * This,
             const DXGI_MATRIX_3X2_F *pMatrix);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMatrixTransform)
         HRESULT ( STDMETHODCALLTYPE *GetMatrixTransform )( 
             IDXGISwapChain3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_MATRIX_3X2_F *pMatrix);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, GetCurrentBackBufferIndex)
         UINT ( STDMETHODCALLTYPE *GetCurrentBackBufferIndex )( 
             IDXGISwapChain3 * This);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, CheckColorSpaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckColorSpaceSupport )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -351,11 +400,13 @@ EXTERN_C const IID IID_IDXGISwapChain3;
             /* [annotation][out] */ 
             _Out_  UINT *pColorSpaceSupport);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, SetColorSpace1)
         HRESULT ( STDMETHODCALLTYPE *SetColorSpace1 )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
             _In_  DXGI_COLOR_SPACE_TYPE ColorSpace);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, ResizeBuffers1)
         HRESULT ( STDMETHODCALLTYPE *ResizeBuffers1 )( 
             IDXGISwapChain3 * This,
             /* [annotation][in] */ 
@@ -571,18 +622,22 @@ EXTERN_C const IID IID_IDXGIOutput4;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIOutput4 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIOutput4 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIOutput4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -591,6 +646,7 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -598,6 +654,7 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -607,6 +664,7 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -614,11 +672,13 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGIOutput4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_OUTPUT_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList)
         HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( 
             IDXGIOutput4 * This,
             /* [in] */ DXGI_FORMAT EnumFormat,
@@ -628,6 +688,7 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][out] */ 
             _Out_writes_to_opt_(*pNumModes,*pNumModes)  DXGI_MODE_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode)
         HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -637,48 +698,58 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][in] */ 
             _In_opt_  IUnknown *pConcernedDevice);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank)
         HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( 
             IDXGIOutput4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership)
         HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
             _In_  IUnknown *pDevice,
             BOOL Exclusive);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership)
         void ( STDMETHODCALLTYPE *ReleaseOwnership )( 
             IDXGIOutput4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities)
         HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( 
             IDXGIOutput4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl)
         HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_GAMMA_CONTROL *pArray);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl)
         HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( 
             IDXGIOutput4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_GAMMA_CONTROL *pArray);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface)
         HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
             _In_  IDXGISurface *pScanoutSurface);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData)
         HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
             _In_  IDXGISurface *pDestination);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics)
         HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( 
             IDXGIOutput4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_FRAME_STATISTICS *pStats);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1)
         HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( 
             IDXGIOutput4 * This,
             /* [in] */ DXGI_FORMAT EnumFormat,
@@ -688,6 +759,7 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][out] */ 
             _Out_writes_to_opt_(*pNumModes,*pNumModes)  DXGI_MODE_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1)
         HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -697,11 +769,13 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][in] */ 
             _In_opt_  IUnknown *pConcernedDevice);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1)
         HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
             _In_  IDXGIResource *pDestination);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput)
         HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -709,9 +783,11 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIOutputDuplication **ppOutputDuplication);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays)
         BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( 
             IDXGIOutput4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport)
         HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -721,6 +797,7 @@ EXTERN_C const IID IID_IDXGIOutput4;
             /* [annotation][out] */ 
             _Out_  UINT *pFlags);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput4, CheckOverlayColorSpaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckOverlayColorSpaceSupport )( 
             IDXGIOutput4 * This,
             /* [annotation][in] */ 
@@ -878,18 +955,22 @@ EXTERN_C const IID IID_IDXGIFactory4;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIFactory4 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIFactory4 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIFactory4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -898,6 +979,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -905,6 +987,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -914,6 +997,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -921,22 +1005,26 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( 
             IDXGIFactory4 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( 
             IDXGIFactory4 * This,
             HWND WindowHandle,
             UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( 
             IDXGIFactory4 * This,
             /* [annotation][out] */ 
             _Out_  HWND *pWindowHandle);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -946,24 +1034,29 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter)
         HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( 
             IDXGIFactory4 * This,
             /* [in] */ HMODULE Module,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( 
             IDXGIFactory4 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter1 **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent)
         BOOL ( STDMETHODCALLTYPE *IsCurrent )( 
             IDXGIFactory4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled)
         BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( 
             IDXGIFactory4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -979,6 +1072,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -992,6 +1086,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid)
         HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( 
             IDXGIFactory4 * This,
             /* [annotation] */ 
@@ -999,6 +1094,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation] */ 
             _Out_  LUID *pLuid);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -1008,6 +1104,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -1015,11 +1112,13 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus)
         void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -1029,6 +1128,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -1036,11 +1136,13 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus)
         void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( 
             IDXGIFactory4 * This,
             /* [annotation][in] */ 
@@ -1052,9 +1154,11 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags)
         UINT ( STDMETHODCALLTYPE *GetCreationFlags )( 
             IDXGIFactory4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( 
             IDXGIFactory4 * This,
             /* [annotation] */ 
@@ -1064,6 +1168,7 @@ EXTERN_C const IID IID_IDXGIFactory4;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter)
         HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( 
             IDXGIFactory4 * This,
             /* [annotation] */ 
@@ -1268,18 +1373,22 @@ EXTERN_C const IID IID_IDXGIAdapter3;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIAdapter3 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIAdapter3 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIAdapter3 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1288,6 +1397,7 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1295,6 +1405,7 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1304,6 +1415,7 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1311,17 +1423,20 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs)
         HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( 
             IDXGIAdapter3 * This,
             /* [in] */ UINT Output,
             /* [annotation][out][in] */ 
             _COM_Outptr_  IDXGIOutput **ppOutput);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGIAdapter3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_ADAPTER_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1329,16 +1444,19 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][out] */ 
             _Out_  LARGE_INTEGER *pUMDVersion);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter1, GetDesc1)
         HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( 
             IDXGIAdapter3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_ADAPTER_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter2, GetDesc2)
         HRESULT ( STDMETHODCALLTYPE *GetDesc2 )( 
             IDXGIAdapter3 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_ADAPTER_DESC2 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterHardwareContentProtectionTeardownStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterHardwareContentProtectionTeardownStatusEvent )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1346,11 +1464,13 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterHardwareContentProtectionTeardownStatus)
         void ( STDMETHODCALLTYPE *UnregisterHardwareContentProtectionTeardownStatus )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, QueryVideoMemoryInfo)
         HRESULT ( STDMETHODCALLTYPE *QueryVideoMemoryInfo )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1360,6 +1480,7 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][out] */ 
             _Out_  DXGI_QUERY_VIDEO_MEMORY_INFO *pVideoMemoryInfo);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, SetVideoMemoryReservation)
         HRESULT ( STDMETHODCALLTYPE *SetVideoMemoryReservation )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1369,6 +1490,7 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][in] */ 
             _In_  UINT64 Reservation);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterVideoMemoryBudgetChangeNotificationEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterVideoMemoryBudgetChangeNotificationEvent )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1376,6 +1498,7 @@ EXTERN_C const IID IID_IDXGIAdapter3;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterVideoMemoryBudgetChangeNotification)
         void ( STDMETHODCALLTYPE *UnregisterVideoMemoryBudgetChangeNotification )( 
             IDXGIAdapter3 * This,
             /* [annotation][in] */ 
@@ -1467,6 +1590,8 @@ EXTERN_C const IID IID_IDXGIAdapter3;
 /* interface __MIDL_itf_dxgi1_4_0000_0004 */
 /* [local] */ 
 
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
 DEFINE_GUID(IID_IDXGISwapChain3,0x94d99bdb,0xf1f8,0x4ab0,0xb2,0x36,0x7d,0xa0,0x17,0x0e,0xda,0xb1);
 DEFINE_GUID(IID_IDXGIOutput4,0xdc7dca35,0x2196,0x414d,0x9F,0x53,0x61,0x78,0x84,0x03,0x2a,0x60);
 DEFINE_GUID(IID_IDXGIFactory4,0x1bc6ea02,0xef36,0x464f,0xbf,0x0c,0x21,0xca,0x39,0xe5,0x16,0x8a);

3rdparty/directx-headers/include/directx/dxgi1_5.h

@@ -3,14 +3,14 @@
 /* this ALWAYS GENERATED file contains the definitions for the interfaces */
 
 
- /* File created by MIDL compiler version 8.01.0622 */
+ /* File created by MIDL compiler version 8.01.0628 */
 /* @@MIDL_FILE_HEADING(  ) */
 
 
 
 /* verify that the <rpcndr.h> version is high enough to compile this file*/
 #ifndef __REQUIRED_RPCNDR_H_VERSION__
-#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#define __REQUIRED_RPCNDR_H_VERSION__ 501
 #endif
 
 /* verify that the <rpcsal.h> version is high enough to compile this file*/
@@ -37,6 +37,14 @@
 #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 __IDXGIOutput5_FWD_DEFINED__
@@ -78,6 +86,9 @@ extern "C"{
 /* interface __MIDL_itf_dxgi1_5_0000_0000 */
 /* [local] */ 
 
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
 typedef 
 enum DXGI_OUTDUPL_FLAG
     {
@@ -124,18 +135,22 @@ EXTERN_C const IID IID_IDXGIOutput5;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIOutput5 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIOutput5 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIOutput5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -144,6 +159,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -151,6 +167,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -160,6 +177,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -167,11 +185,13 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGIOutput5 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_OUTPUT_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList)
         HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( 
             IDXGIOutput5 * This,
             /* [in] */ DXGI_FORMAT EnumFormat,
@@ -181,6 +201,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][out] */ 
             _Out_writes_to_opt_(*pNumModes,*pNumModes)  DXGI_MODE_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode)
         HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -190,48 +211,58 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][in] */ 
             _In_opt_  IUnknown *pConcernedDevice);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank)
         HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( 
             IDXGIOutput5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership)
         HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
             _In_  IUnknown *pDevice,
             BOOL Exclusive);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership)
         void ( STDMETHODCALLTYPE *ReleaseOwnership )( 
             IDXGIOutput5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities)
         HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( 
             IDXGIOutput5 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl)
         HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_GAMMA_CONTROL *pArray);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl)
         HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( 
             IDXGIOutput5 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_GAMMA_CONTROL *pArray);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface)
         HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
             _In_  IDXGISurface *pScanoutSurface);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData)
         HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
             _In_  IDXGISurface *pDestination);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics)
         HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( 
             IDXGIOutput5 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_FRAME_STATISTICS *pStats);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1)
         HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( 
             IDXGIOutput5 * This,
             /* [in] */ DXGI_FORMAT EnumFormat,
@@ -241,6 +272,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][out] */ 
             _Out_writes_to_opt_(*pNumModes,*pNumModes)  DXGI_MODE_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1)
         HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -250,11 +282,13 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][in] */ 
             _In_opt_  IUnknown *pConcernedDevice);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1)
         HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
             _In_  IDXGIResource *pDestination);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput)
         HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -262,9 +296,11 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIOutputDuplication **ppOutputDuplication);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays)
         BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( 
             IDXGIOutput5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport)
         HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -274,6 +310,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][out] */ 
             _Out_  UINT *pFlags);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput4, CheckOverlayColorSpaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckOverlayColorSpaceSupport )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -285,6 +322,7 @@ EXTERN_C const IID IID_IDXGIOutput5;
             /* [annotation][out] */ 
             _Out_  UINT *pFlags);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput5, DuplicateOutput1)
         HRESULT ( STDMETHODCALLTYPE *DuplicateOutput1 )( 
             IDXGIOutput5 * This,
             /* [annotation][in] */ 
@@ -474,18 +512,22 @@ EXTERN_C const IID IID_IDXGISwapChain4;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGISwapChain4 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGISwapChain4 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGISwapChain4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -494,6 +536,7 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -501,6 +544,7 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -510,6 +554,7 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -517,6 +562,7 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIDeviceSubObject, GetDevice)
         HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -524,11 +570,13 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppDevice);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, Present)
         HRESULT ( STDMETHODCALLTYPE *Present )( 
             IDXGISwapChain4 * This,
             /* [in] */ UINT SyncInterval,
             /* [in] */ UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetBuffer)
         HRESULT ( STDMETHODCALLTYPE *GetBuffer )( 
             IDXGISwapChain4 * This,
             /* [in] */ UINT Buffer,
@@ -537,12 +585,14 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][out][in] */ 
             _COM_Outptr_  void **ppSurface);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, SetFullscreenState)
         HRESULT ( STDMETHODCALLTYPE *SetFullscreenState )( 
             IDXGISwapChain4 * This,
             /* [in] */ BOOL Fullscreen,
             /* [annotation][in] */ 
             _In_opt_  IDXGIOutput *pTarget);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetFullscreenState)
         HRESULT ( STDMETHODCALLTYPE *GetFullscreenState )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
@@ -550,11 +600,13 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][out] */ 
             _COM_Outptr_opt_result_maybenull_  IDXGIOutput **ppTarget);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_SWAP_CHAIN_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeBuffers)
         HRESULT ( STDMETHODCALLTYPE *ResizeBuffers )( 
             IDXGISwapChain4 * This,
             /* [in] */ UINT BufferCount,
@@ -563,41 +615,49 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [in] */ DXGI_FORMAT NewFormat,
             /* [in] */ UINT SwapChainFlags);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, ResizeTarget)
         HRESULT ( STDMETHODCALLTYPE *ResizeTarget )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_MODE_DESC *pNewTargetParameters);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetContainingOutput)
         HRESULT ( STDMETHODCALLTYPE *GetContainingOutput )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIOutput **ppOutput);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetFrameStatistics)
         HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_FRAME_STATISTICS *pStats);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain, GetLastPresentCount)
         HRESULT ( STDMETHODCALLTYPE *GetLastPresentCount )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  UINT *pLastPresentCount);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetDesc1)
         HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_SWAP_CHAIN_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetFullscreenDesc)
         HRESULT ( STDMETHODCALLTYPE *GetFullscreenDesc )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_SWAP_CHAIN_FULLSCREEN_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetHwnd)
         HRESULT ( STDMETHODCALLTYPE *GetHwnd )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  HWND *pHwnd);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetCoreWindow)
         HRESULT ( STDMETHODCALLTYPE *GetCoreWindow )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -605,6 +665,7 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][out] */ 
             _COM_Outptr_  void **ppUnk);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, Present1)
         HRESULT ( STDMETHODCALLTYPE *Present1 )( 
             IDXGISwapChain4 * This,
             /* [in] */ UINT SyncInterval,
@@ -612,39 +673,47 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][in] */ 
             _In_  const DXGI_PRESENT_PARAMETERS *pPresentParameters);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, IsTemporaryMonoSupported)
         BOOL ( STDMETHODCALLTYPE *IsTemporaryMonoSupported )( 
             IDXGISwapChain4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRestrictToOutput)
         HRESULT ( STDMETHODCALLTYPE *GetRestrictToOutput )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  IDXGIOutput **ppRestrictToOutput);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, SetBackgroundColor)
         HRESULT ( STDMETHODCALLTYPE *SetBackgroundColor )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_RGBA *pColor);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetBackgroundColor)
         HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_RGBA *pColor);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, SetRotation)
         HRESULT ( STDMETHODCALLTYPE *SetRotation )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
             _In_  DXGI_MODE_ROTATION Rotation);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain1, GetRotation)
         HRESULT ( STDMETHODCALLTYPE *GetRotation )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_MODE_ROTATION *pRotation);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, SetSourceSize)
         HRESULT ( STDMETHODCALLTYPE *SetSourceSize )( 
             IDXGISwapChain4 * This,
             UINT Width,
             UINT Height);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetSourceSize)
         HRESULT ( STDMETHODCALLTYPE *GetSourceSize )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
@@ -652,30 +721,37 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][out] */ 
             _Out_  UINT *pHeight);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMaximumFrameLatency)
         HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( 
             IDXGISwapChain4 * This,
             UINT MaxLatency);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMaximumFrameLatency)
         HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  UINT *pMaxLatency);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetFrameLatencyWaitableObject)
         HANDLE ( STDMETHODCALLTYPE *GetFrameLatencyWaitableObject )( 
             IDXGISwapChain4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, SetMatrixTransform)
         HRESULT ( STDMETHODCALLTYPE *SetMatrixTransform )( 
             IDXGISwapChain4 * This,
             const DXGI_MATRIX_3X2_F *pMatrix);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain2, GetMatrixTransform)
         HRESULT ( STDMETHODCALLTYPE *GetMatrixTransform )( 
             IDXGISwapChain4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_MATRIX_3X2_F *pMatrix);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, GetCurrentBackBufferIndex)
         UINT ( STDMETHODCALLTYPE *GetCurrentBackBufferIndex )( 
             IDXGISwapChain4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, CheckColorSpaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckColorSpaceSupport )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -683,11 +759,13 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][out] */ 
             _Out_  UINT *pColorSpaceSupport);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, SetColorSpace1)
         HRESULT ( STDMETHODCALLTYPE *SetColorSpace1 )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
             _In_  DXGI_COLOR_SPACE_TYPE ColorSpace);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain3, ResizeBuffers1)
         HRESULT ( STDMETHODCALLTYPE *ResizeBuffers1 )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -705,6 +783,7 @@ EXTERN_C const IID IID_IDXGISwapChain4;
             /* [annotation][in] */ 
             _In_reads_(BufferCount)  IUnknown *const *ppPresentQueue);
         
+        DECLSPEC_XFGVIRT(IDXGISwapChain4, SetHDRMetaData)
         HRESULT ( STDMETHODCALLTYPE *SetHDRMetaData )( 
             IDXGISwapChain4 * This,
             /* [annotation][in] */ 
@@ -932,18 +1011,22 @@ EXTERN_C const IID IID_IDXGIDevice4;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIDevice4 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIDevice4 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIDevice4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -952,6 +1035,7 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -959,6 +1043,7 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -968,6 +1053,7 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -975,11 +1061,13 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice, GetAdapter)
         HRESULT ( STDMETHODCALLTYPE *GetAdapter )( 
             IDXGIDevice4 * This,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **pAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice, CreateSurface)
         HRESULT ( STDMETHODCALLTYPE *CreateSurface )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -988,9 +1076,10 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [in] */ DXGI_USAGE Usage,
             /* [annotation][in] */ 
             _In_opt_  const DXGI_SHARED_RESOURCE *pSharedResource,
-            /* [annotation][out] */ 
-            _COM_Outptr_  IDXGISurface **ppSurface);
+            /* [annotation][size_is][out] */ 
+            _Out_writes_(NumSurfaces)  IDXGISurface **ppSurface);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice, QueryResourceResidency)
         HRESULT ( STDMETHODCALLTYPE *QueryResourceResidency )( 
             IDXGIDevice4 * This,
             /* [annotation][size_is][in] */ 
@@ -999,24 +1088,29 @@ EXTERN_C const IID IID_IDXGIDevice4;
             _Out_writes_(NumResources)  DXGI_RESIDENCY *pResidencyStatus,
             /* [in] */ UINT NumResources);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice, SetGPUThreadPriority)
         HRESULT ( STDMETHODCALLTYPE *SetGPUThreadPriority )( 
             IDXGIDevice4 * This,
             /* [in] */ INT Priority);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice, GetGPUThreadPriority)
         HRESULT ( STDMETHODCALLTYPE *GetGPUThreadPriority )( 
             IDXGIDevice4 * This,
             /* [annotation][retval][out] */ 
             _Out_  INT *pPriority);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice1, SetMaximumFrameLatency)
         HRESULT ( STDMETHODCALLTYPE *SetMaximumFrameLatency )( 
             IDXGIDevice4 * This,
             /* [in] */ UINT MaxLatency);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice1, GetMaximumFrameLatency)
         HRESULT ( STDMETHODCALLTYPE *GetMaximumFrameLatency )( 
             IDXGIDevice4 * This,
             /* [annotation][out] */ 
             _Out_  UINT *pMaxLatency);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice2, OfferResources)
         HRESULT ( STDMETHODCALLTYPE *OfferResources )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -1026,6 +1120,7 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][in] */ 
             _In_  DXGI_OFFER_RESOURCE_PRIORITY Priority);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice2, ReclaimResources)
         HRESULT ( STDMETHODCALLTYPE *ReclaimResources )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -1035,14 +1130,17 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][size_is][out] */ 
             _Out_writes_all_opt_(NumResources)  BOOL *pDiscarded);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice2, EnqueueSetEvent)
         HRESULT ( STDMETHODCALLTYPE *EnqueueSetEvent )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
             _In_  HANDLE hEvent);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice3, Trim)
         void ( STDMETHODCALLTYPE *Trim )( 
             IDXGIDevice4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice4, OfferResources1)
         HRESULT ( STDMETHODCALLTYPE *OfferResources1 )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -1054,6 +1152,7 @@ EXTERN_C const IID IID_IDXGIDevice4;
             /* [annotation][in] */ 
             _In_  UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGIDevice4, ReclaimResources1)
         HRESULT ( STDMETHODCALLTYPE *ReclaimResources1 )( 
             IDXGIDevice4 * This,
             /* [annotation][in] */ 
@@ -1197,18 +1296,22 @@ EXTERN_C const IID IID_IDXGIFactory5;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIFactory5 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIFactory5 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIFactory5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1217,6 +1320,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1224,6 +1328,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1233,6 +1338,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1240,22 +1346,26 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( 
             IDXGIFactory5 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( 
             IDXGIFactory5 * This,
             HWND WindowHandle,
             UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( 
             IDXGIFactory5 * This,
             /* [annotation][out] */ 
             _Out_  HWND *pWindowHandle);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1265,24 +1375,29 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter)
         HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( 
             IDXGIFactory5 * This,
             /* [in] */ HMODULE Module,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( 
             IDXGIFactory5 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter1 **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent)
         BOOL ( STDMETHODCALLTYPE *IsCurrent )( 
             IDXGIFactory5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled)
         BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( 
             IDXGIFactory5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1298,6 +1413,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1311,6 +1427,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid)
         HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( 
             IDXGIFactory5 * This,
             /* [annotation] */ 
@@ -1318,6 +1435,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation] */ 
             _Out_  LUID *pLuid);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1327,6 +1445,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1334,11 +1453,13 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus)
         void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1348,6 +1469,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1355,11 +1477,13 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus)
         void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( 
             IDXGIFactory5 * This,
             /* [annotation][in] */ 
@@ -1371,9 +1495,11 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags)
         UINT ( STDMETHODCALLTYPE *GetCreationFlags )( 
             IDXGIFactory5 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( 
             IDXGIFactory5 * This,
             /* [annotation] */ 
@@ -1383,6 +1509,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter)
         HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( 
             IDXGIFactory5 * This,
             /* [annotation] */ 
@@ -1390,6 +1517,7 @@ EXTERN_C const IID IID_IDXGIFactory5;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory5, CheckFeatureSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
             IDXGIFactory5 * This,
             DXGI_FEATURE Feature,
@@ -1518,6 +1646,8 @@ EXTERN_C const IID IID_IDXGIFactory5;
 /* interface __MIDL_itf_dxgi1_5_0000_0004 */
 /* [local] */ 
 
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
 DEFINE_GUID(IID_IDXGIOutput5,0x80A07424,0xAB52,0x42EB,0x83,0x3C,0x0C,0x42,0xFD,0x28,0x2D,0x98);
 DEFINE_GUID(IID_IDXGISwapChain4,0x3D585D5A,0xBD4A,0x489E,0xB1,0xF4,0x3D,0xBC,0xB6,0x45,0x2F,0xFB);
 DEFINE_GUID(IID_IDXGIDevice4,0x95B4F95F,0xD8DA,0x4CA4,0x9E,0xE6,0x3B,0x76,0xD5,0x96,0x8A,0x10);

3rdparty/directx-headers/include/directx/dxgi1_6.h

@@ -3,14 +3,14 @@
 /* this ALWAYS GENERATED file contains the definitions for the interfaces */
 
 
- /* File created by MIDL compiler version 8.01.0622 */
+ /* File created by MIDL compiler version 8.01.0628 */
 /* @@MIDL_FILE_HEADING(  ) */
 
 
 
 /* verify that the <rpcndr.h> version is high enough to compile this file*/
 #ifndef __REQUIRED_RPCNDR_H_VERSION__
-#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#define __REQUIRED_RPCNDR_H_VERSION__ 501
 #endif
 
 /* verify that the <rpcsal.h> version is high enough to compile this file*/
@@ -37,6 +37,14 @@
 #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 __IDXGIAdapter4_FWD_DEFINED__
@@ -79,6 +87,9 @@ extern "C"{
 /* [local] */ 
 
 // Copyright (c) Microsoft Corporation.  All Rights Reserved
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
 HRESULT WINAPI DXGIDeclareAdapterRemovalSupport();
 typedef 
 enum DXGI_ADAPTER_FLAG3
@@ -143,18 +154,22 @@ EXTERN_C const IID IID_IDXGIAdapter4;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIAdapter4 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIAdapter4 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIAdapter4 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -163,6 +178,7 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -170,6 +186,7 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -179,6 +196,7 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -186,17 +204,20 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter, EnumOutputs)
         HRESULT ( STDMETHODCALLTYPE *EnumOutputs )( 
             IDXGIAdapter4 * This,
             /* [in] */ UINT Output,
             /* [annotation][out][in] */ 
             _COM_Outptr_  IDXGIOutput **ppOutput);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGIAdapter4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_ADAPTER_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter, CheckInterfaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckInterfaceSupport )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -204,16 +225,19 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][out] */ 
             _Out_  LARGE_INTEGER *pUMDVersion);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter1, GetDesc1)
         HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( 
             IDXGIAdapter4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_ADAPTER_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter2, GetDesc2)
         HRESULT ( STDMETHODCALLTYPE *GetDesc2 )( 
             IDXGIAdapter4 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_ADAPTER_DESC2 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterHardwareContentProtectionTeardownStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterHardwareContentProtectionTeardownStatusEvent )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -221,11 +245,13 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterHardwareContentProtectionTeardownStatus)
         void ( STDMETHODCALLTYPE *UnregisterHardwareContentProtectionTeardownStatus )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, QueryVideoMemoryInfo)
         HRESULT ( STDMETHODCALLTYPE *QueryVideoMemoryInfo )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -235,6 +261,7 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][out] */ 
             _Out_  DXGI_QUERY_VIDEO_MEMORY_INFO *pVideoMemoryInfo);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, SetVideoMemoryReservation)
         HRESULT ( STDMETHODCALLTYPE *SetVideoMemoryReservation )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -244,6 +271,7 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][in] */ 
             _In_  UINT64 Reservation);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, RegisterVideoMemoryBudgetChangeNotificationEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterVideoMemoryBudgetChangeNotificationEvent )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
@@ -251,11 +279,13 @@ EXTERN_C const IID IID_IDXGIAdapter4;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter3, UnregisterVideoMemoryBudgetChangeNotification)
         void ( STDMETHODCALLTYPE *UnregisterVideoMemoryBudgetChangeNotification )( 
             IDXGIAdapter4 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIAdapter4, GetDesc3)
         HRESULT ( STDMETHODCALLTYPE *GetDesc3 )( 
             IDXGIAdapter4 * This,
             /* [annotation][out] */ 
@@ -415,18 +445,22 @@ EXTERN_C const IID IID_IDXGIOutput6;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIOutput6 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIOutput6 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIOutput6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -435,6 +469,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -442,6 +477,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -451,6 +487,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -458,11 +495,13 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDesc)
         HRESULT ( STDMETHODCALLTYPE *GetDesc )( 
             IDXGIOutput6 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_OUTPUT_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplayModeList)
         HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList )( 
             IDXGIOutput6 * This,
             /* [in] */ DXGI_FORMAT EnumFormat,
@@ -472,6 +511,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _Out_writes_to_opt_(*pNumModes,*pNumModes)  DXGI_MODE_DESC *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, FindClosestMatchingMode)
         HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -481,48 +521,58 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][in] */ 
             _In_opt_  IUnknown *pConcernedDevice);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, WaitForVBlank)
         HRESULT ( STDMETHODCALLTYPE *WaitForVBlank )( 
             IDXGIOutput6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, TakeOwnership)
         HRESULT ( STDMETHODCALLTYPE *TakeOwnership )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
             _In_  IUnknown *pDevice,
             BOOL Exclusive);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, ReleaseOwnership)
         void ( STDMETHODCALLTYPE *ReleaseOwnership )( 
             IDXGIOutput6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControlCapabilities)
         HRESULT ( STDMETHODCALLTYPE *GetGammaControlCapabilities )( 
             IDXGIOutput6 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, SetGammaControl)
         HRESULT ( STDMETHODCALLTYPE *SetGammaControl )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
             _In_  const DXGI_GAMMA_CONTROL *pArray);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetGammaControl)
         HRESULT ( STDMETHODCALLTYPE *GetGammaControl )( 
             IDXGIOutput6 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_GAMMA_CONTROL *pArray);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, SetDisplaySurface)
         HRESULT ( STDMETHODCALLTYPE *SetDisplaySurface )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
             _In_  IDXGISurface *pScanoutSurface);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetDisplaySurfaceData)
         HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
             _In_  IDXGISurface *pDestination);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput, GetFrameStatistics)
         HRESULT ( STDMETHODCALLTYPE *GetFrameStatistics )( 
             IDXGIOutput6 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_FRAME_STATISTICS *pStats);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplayModeList1)
         HRESULT ( STDMETHODCALLTYPE *GetDisplayModeList1 )( 
             IDXGIOutput6 * This,
             /* [in] */ DXGI_FORMAT EnumFormat,
@@ -532,6 +582,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _Out_writes_to_opt_(*pNumModes,*pNumModes)  DXGI_MODE_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, FindClosestMatchingMode1)
         HRESULT ( STDMETHODCALLTYPE *FindClosestMatchingMode1 )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -541,11 +592,13 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][in] */ 
             _In_opt_  IUnknown *pConcernedDevice);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, GetDisplaySurfaceData1)
         HRESULT ( STDMETHODCALLTYPE *GetDisplaySurfaceData1 )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
             _In_  IDXGIResource *pDestination);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput1, DuplicateOutput)
         HRESULT ( STDMETHODCALLTYPE *DuplicateOutput )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -553,9 +606,11 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIOutputDuplication **ppOutputDuplication);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput2, SupportsOverlays)
         BOOL ( STDMETHODCALLTYPE *SupportsOverlays )( 
             IDXGIOutput6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput3, CheckOverlaySupport)
         HRESULT ( STDMETHODCALLTYPE *CheckOverlaySupport )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -565,6 +620,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _Out_  UINT *pFlags);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput4, CheckOverlayColorSpaceSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckOverlayColorSpaceSupport )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -576,6 +632,7 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _Out_  UINT *pFlags);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput5, DuplicateOutput1)
         HRESULT ( STDMETHODCALLTYPE *DuplicateOutput1 )( 
             IDXGIOutput6 * This,
             /* [annotation][in] */ 
@@ -588,11 +645,13 @@ EXTERN_C const IID IID_IDXGIOutput6;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIOutputDuplication **ppOutputDuplication);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput6, GetDesc1)
         HRESULT ( STDMETHODCALLTYPE *GetDesc1 )( 
             IDXGIOutput6 * This,
             /* [annotation][out] */ 
             _Out_  DXGI_OUTPUT_DESC1 *pDesc);
         
+        DECLSPEC_XFGVIRT(IDXGIOutput6, CheckHardwareCompositionSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckHardwareCompositionSupport )( 
             IDXGIOutput6 * This,
             /* [annotation][out] */ 
@@ -767,18 +826,22 @@ EXTERN_C const IID IID_IDXGIFactory6;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIFactory6 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIFactory6 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIFactory6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -787,6 +850,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -794,6 +858,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -803,6 +868,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -810,22 +876,26 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( 
             IDXGIFactory6 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( 
             IDXGIFactory6 * This,
             HWND WindowHandle,
             UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( 
             IDXGIFactory6 * This,
             /* [annotation][out] */ 
             _Out_  HWND *pWindowHandle);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -835,24 +905,29 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter)
         HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( 
             IDXGIFactory6 * This,
             /* [in] */ HMODULE Module,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( 
             IDXGIFactory6 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter1 **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent)
         BOOL ( STDMETHODCALLTYPE *IsCurrent )( 
             IDXGIFactory6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled)
         BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( 
             IDXGIFactory6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -868,6 +943,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -881,6 +957,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid)
         HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( 
             IDXGIFactory6 * This,
             /* [annotation] */ 
@@ -888,6 +965,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation] */ 
             _Out_  LUID *pLuid);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -897,6 +975,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -904,11 +983,13 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus)
         void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -918,6 +999,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -925,11 +1007,13 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus)
         void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( 
             IDXGIFactory6 * This,
             /* [annotation][in] */ 
@@ -941,9 +1025,11 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags)
         UINT ( STDMETHODCALLTYPE *GetCreationFlags )( 
             IDXGIFactory6 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( 
             IDXGIFactory6 * This,
             /* [annotation] */ 
@@ -953,6 +1039,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter)
         HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( 
             IDXGIFactory6 * This,
             /* [annotation] */ 
@@ -960,6 +1047,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory5, CheckFeatureSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
             IDXGIFactory6 * This,
             DXGI_FEATURE Feature,
@@ -967,6 +1055,7 @@ EXTERN_C const IID IID_IDXGIFactory6;
             _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
             UINT FeatureSupportDataSize);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory6, EnumAdapterByGpuPreference)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapterByGpuPreference )( 
             IDXGIFactory6 * This,
             /* [annotation] */ 
@@ -1134,18 +1223,22 @@ EXTERN_C const IID IID_IDXGIFactory7;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             IDXGIFactory7 * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             IDXGIFactory7 * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             IDXGIFactory7 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1154,6 +1247,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][in] */ 
             _In_reads_bytes_(DataSize)  const void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, SetPrivateDataInterface)
         HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1161,6 +1255,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][in] */ 
             _In_opt_  const IUnknown *pUnknown);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetPrivateData)
         HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1170,6 +1265,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _Out_writes_bytes_(*pDataSize)  void *pData);
         
+        DECLSPEC_XFGVIRT(IDXGIObject, GetParent)
         HRESULT ( STDMETHODCALLTYPE *GetParent )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1177,22 +1273,26 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][retval][out] */ 
             _COM_Outptr_  void **ppParent);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, EnumAdapters)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters )( 
             IDXGIFactory7 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, MakeWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *MakeWindowAssociation )( 
             IDXGIFactory7 * This,
             HWND WindowHandle,
             UINT Flags);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, GetWindowAssociation)
         HRESULT ( STDMETHODCALLTYPE *GetWindowAssociation )( 
             IDXGIFactory7 * This,
             /* [annotation][out] */ 
             _Out_  HWND *pWindowHandle);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSwapChain)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChain )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1202,24 +1302,29 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory, CreateSoftwareAdapter)
         HRESULT ( STDMETHODCALLTYPE *CreateSoftwareAdapter )( 
             IDXGIFactory7 * This,
             /* [in] */ HMODULE Module,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, EnumAdapters1)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapters1 )( 
             IDXGIFactory7 * This,
             /* [in] */ UINT Adapter,
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGIAdapter1 **ppAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory1, IsCurrent)
         BOOL ( STDMETHODCALLTYPE *IsCurrent )( 
             IDXGIFactory7 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, IsWindowedStereoEnabled)
         BOOL ( STDMETHODCALLTYPE *IsWindowedStereoEnabled )( 
             IDXGIFactory7 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForHwnd)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForHwnd )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1235,6 +1340,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForCoreWindow)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForCoreWindow )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1248,6 +1354,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, GetSharedResourceAdapterLuid)
         HRESULT ( STDMETHODCALLTYPE *GetSharedResourceAdapterLuid )( 
             IDXGIFactory7 * This,
             /* [annotation] */ 
@@ -1255,6 +1362,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation] */ 
             _Out_  LUID *pLuid);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusWindow )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1264,6 +1372,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterStereoStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterStereoStatusEvent )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1271,11 +1380,13 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterStereoStatus)
         void ( STDMETHODCALLTYPE *UnregisterStereoStatus )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusWindow)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusWindow )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1285,6 +1396,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, RegisterOcclusionStatusEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterOcclusionStatusEvent )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1292,11 +1404,13 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, UnregisterOcclusionStatus)
         void ( STDMETHODCALLTYPE *UnregisterOcclusionStatus )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
             _In_  DWORD dwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory2, CreateSwapChainForComposition)
         HRESULT ( STDMETHODCALLTYPE *CreateSwapChainForComposition )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1308,9 +1422,11 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _COM_Outptr_  IDXGISwapChain1 **ppSwapChain);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory3, GetCreationFlags)
         UINT ( STDMETHODCALLTYPE *GetCreationFlags )( 
             IDXGIFactory7 * This);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumAdapterByLuid)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapterByLuid )( 
             IDXGIFactory7 * This,
             /* [annotation] */ 
@@ -1320,6 +1436,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory4, EnumWarpAdapter)
         HRESULT ( STDMETHODCALLTYPE *EnumWarpAdapter )( 
             IDXGIFactory7 * This,
             /* [annotation] */ 
@@ -1327,6 +1444,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory5, CheckFeatureSupport)
         HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
             IDXGIFactory7 * This,
             DXGI_FEATURE Feature,
@@ -1334,6 +1452,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
             UINT FeatureSupportDataSize);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory6, EnumAdapterByGpuPreference)
         HRESULT ( STDMETHODCALLTYPE *EnumAdapterByGpuPreference )( 
             IDXGIFactory7 * This,
             /* [annotation] */ 
@@ -1345,6 +1464,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation] */ 
             _COM_Outptr_  void **ppvAdapter);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory7, RegisterAdaptersChangedEvent)
         HRESULT ( STDMETHODCALLTYPE *RegisterAdaptersChangedEvent )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1352,6 +1472,7 @@ EXTERN_C const IID IID_IDXGIFactory7;
             /* [annotation][out] */ 
             _Out_  DWORD *pdwCookie);
         
+        DECLSPEC_XFGVIRT(IDXGIFactory7, UnregisterAdaptersChangedEvent)
         HRESULT ( STDMETHODCALLTYPE *UnregisterAdaptersChangedEvent )( 
             IDXGIFactory7 * This,
             /* [annotation][in] */ 
@@ -1489,6 +1610,11 @@ EXTERN_C const IID IID_IDXGIFactory7;
 /* interface __MIDL_itf_dxgi1_6_0000_0004 */
 /* [local] */ 
 
+#if defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_WIN10_NI)
+HRESULT WINAPI DXGIDisableVBlankVirtualization();
+#endif
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
 DEFINE_GUID(IID_IDXGIAdapter4,0x3c8d99d1,0x4fbf,0x4181,0xa8,0x2c,0xaf,0x66,0xbf,0x7b,0xd2,0x4e);
 DEFINE_GUID(IID_IDXGIOutput6,0x068346e8,0xaaec,0x4b84,0xad,0xd7,0x13,0x7f,0x51,0x3f,0x77,0xa1);
 DEFINE_GUID(IID_IDXGIFactory6,0xc1b6694f,0xff09,0x44a9,0xb0,0x3c,0x77,0x90,0x0a,0x0a,0x1d,0x17);

3rdparty/directx-headers/include/directx/dxgicommon.h

@@ -7,6 +7,7 @@
 #define __dxgicommon_h__
 
 
+
 typedef struct DXGI_RATIONAL
 {
     UINT Numerator;

3rdparty/directx-headers/include/directx/dxgiformat.h

@@ -135,6 +135,8 @@ typedef enum DXGI_FORMAT
     DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE         = 189,
     DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190,
 
+    DXGI_FORMAT_A4B4G4R4_UNORM                          = 191,
+
 
     DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
 } DXGI_FORMAT;

3rdparty/directx-headers/include/directx/pix3_win.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #ifndef _PIX3_H_
-#error Don't include this file directly - use pix3.h
+#error "Don't include this file directly - use pix3.h"
 #endif
 
 #ifndef _PIX3_WIN_H_