[PATCH 1/1] include: Update the d3d12 headers from vkd3d.

[Martin Storsjö]

From: Martin Storsjö

This corresponds to vkd3d as of commit
e597b0d80f39f716a8740cb0be55edc78f4599d6.

This brings in a function signature fix for the implementation
of ID3D12CommandQueue::UpdateTileMappings() as well, from
vkd3d commit e98e6c9b530995e68bd019a3319d90223ed864cf.

Signed-off-by: Martin Storsjö 
---
 include/d3d12.idl               | 2648 ++++++++++++++++++++++++++++++-
 libs/vkd3d/libs/vkd3d/command.c |    2 +-
 2 files changed, 2568 insertions(+), 82 deletions(-)

diff --git a/include/d3d12.idl b/include/d3d12.idl
index 4fec32d2656..9744b9c9cb5 100644
--- a/include/d3d12.idl
+++ b/include/d3d12.idl
@@ -24,57 +24,427 @@ import "d3dcommon.idl";
 cpp_quote("#ifndef _D3D12_CONSTANTS")
 cpp_quote("#define _D3D12_CONSTANTS")

-const UINT D3D12_CS_TGSM_REGISTER_COUNT = 8192;
-const UINT D3D12_MAX_ROOT_COST = 64;
-const UINT D3D12_VIEWPORT_BOUNDS_MAX = 32767;
-const UINT D3D12_VIEWPORT_BOUNDS_MIN = -32768;
-
-const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15;
-
+const UINT D3D12_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff;
+const UINT D3D12_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff;
+const UINT D3D12_8BIT_INDEX_STRIP_CUT_VALUE = 0xff;
 const UINT D3D12_APPEND_ALIGNED_ELEMENT = 0xffffffff;
+const UINT D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9;
+const UINT D3D12_CLIP_OR_CULL_DISTANCE_COUNT = 8;
+const UINT D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1;
+const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1;
+const UINT D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64;
+const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4;
+const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1;
+const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1;
+const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1;
+const UINT D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1;
+const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128;
+const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1;
+const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1;
+const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128;
+const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1;
+const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16;
+const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1;
+const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1;
+const UINT D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT = 16;
+const UINT D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32;
+const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4;
+const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COUNT = 4096;
+const UINT D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3;
+const UINT D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3;
+const UINT D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10;
+const INT D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10;
+const INT D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8;
+const UINT D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7;
+const UINT D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = 256;
+const UINT D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256;
+const UINT D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64;
+const UINT D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240;
+const UINT D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68;
+const UINT D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224;
+const UINT D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72;
+const UINT D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208;
+const UINT D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76;
+const UINT D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192;
+const UINT D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84;
+const UINT D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176;
+const UINT D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92;
+const UINT D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160;
+const UINT D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100;
+const UINT D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144;
+const UINT D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112;
+const UINT D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128;
+const UINT D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128;
+const UINT D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112;
+const UINT D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144;
+const UINT D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96;
+const UINT D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168;
+const UINT D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80;
+const UINT D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204;
+const UINT D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64;
+const UINT D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256;
+const UINT D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48;
+const UINT D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340;
+const UINT D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32;
+const UINT D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512;
+const UINT D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16;
+const UINT D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768;
+const UINT D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1;
+const UINT D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256;
+const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768;
+const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_X = 768;
+const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_Y = 768;
+const UINT D3D12_CS_4_X_UAV_REGISTER_COUNT = 1;
+const UINT D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535;
+const UINT D3D12_CS_TGSM_REGISTER_COUNT = 8192;
+const UINT D3D12_CS_TGSM_REGISTER_READS_PER_INST = 1;
+const UINT D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1;
+const UINT D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1;
+const UINT D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS = 3;
+const UINT D3D12_CS_THREADGROUPID_REGISTER_COUNT = 1;
+const UINT D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = 1;
+const UINT D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = 1;
+const UINT D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS = 3;
+const UINT D3D12_CS_THREADIDINGROUP_REGISTER_COUNT = 1;
+const UINT D3D12_CS_THREADID_REGISTER_COMPONENTS = 3;
+const UINT D3D12_CS_THREADID_REGISTER_COUNT = 1;
+const UINT D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024;
+const UINT D3D12_CS_THREAD_GROUP_MAX_X = 1024;
+const UINT D3D12_CS_THREAD_GROUP_MAX_Y = 1024;
+const UINT D3D12_CS_THREAD_GROUP_MAX_Z = 64;
+const UINT D3D12_CS_THREAD_GROUP_MIN_X = 1;
+const UINT D3D12_CS_THREAD_GROUP_MIN_Y = 1;
+const UINT D3D12_CS_THREAD_GROUP_MIN_Z = 1;
+const UINT D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384;
 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA (1.0f)")
 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_BLUE (1.0f)")
 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_GREEN (1.0f)")
 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_RED (1.0f)")
+cpp_quote("#define D3D12_DEFAULT_BORDER_COLOR_COMPONENT (0.0f)")
 const UINT D3D12_DEFAULT_DEPTH_BIAS = 0;
 cpp_quote("#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP (0.0f)")
+const UINT D3D12_DEFAULT_MAX_ANISOTROPY = 16;
+cpp_quote("#define D3D12_DEFAULT_MIP_LOD_BIAS (0.0f)")
+const UINT D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 4194304;
+const UINT D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0;
+const UINT D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
+const UINT D3D12_DEFAULT_SAMPLE_MASK = 0xffffffff;
+const UINT D3D12_DEFAULT_SCISSOR_ENDX = 0;
+const UINT D3D12_DEFAULT_SCISSOR_ENDY = 0;
+const UINT D3D12_DEFAULT_SCISSOR_STARTX = 0;
+const UINT D3D12_DEFAULT_SCISSOR_STARTY = 0;
 cpp_quote("#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS (0.0f)")
 const UINT D3D12_DEFAULT_STENCIL_READ_MASK = 0xff;
+const UINT D3D12_DEFAULT_STENCIL_REFERENCE = 0;
 const UINT D3D12_DEFAULT_STENCIL_WRITE_MASK = 0xff;
+const UINT D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0;
+const UINT D3D12_DEFAULT_VIEWPORT_HEIGHT = 0;
+cpp_quote("#define D3D12_DEFAULT_VIEWPORT_MAX_DEPTH (0.0f)")
+cpp_quote("#define D3D12_DEFAULT_VIEWPORT_MIN_DEPTH (0.0f)")
+const UINT D3D12_DEFAULT_VIEWPORT_TOPLEFTX = 0;
+const UINT D3D12_DEFAULT_VIEWPORT_TOPLEFTY = 0;
+const UINT D3D12_DEFAULT_VIEWPORT_WIDTH = 0;
 const UINT D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND = 0xffffffff;
+const UINT D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END = 0xfffffff7;
+const UINT D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff0;
+const UINT D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968;
+const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = 32;
+const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = 3;
+const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = 1;
+const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = 32;
+const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1;
+const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1;
+const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1;
+const UINT D3D12_DS_OUTPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_DS_OUTPUT_REGISTER_COUNT = 32;
+cpp_quote("#define D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP (0.6)")
 cpp_quote("#define D3D12_FLOAT32_MAX (3.402823466e+38f)")
+cpp_quote("#define D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP (0.6f)")
+cpp_quote("#define D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR (2.4f)")
+cpp_quote("#define D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR (1.0f)")
+cpp_quote("#define D3D12_FLOAT_TO_SRGB_OFFSET (0.055f)")
+cpp_quote("#define D3D12_FLOAT_TO_SRGB_SCALE_1 (12.92f)")
+cpp_quote("#define D3D12_FLOAT_TO_SRGB_SCALE_2 (1.055f)")
+cpp_quote("#define D3D12_FLOAT_TO_SRGB_THRESHOLD (0.0031308f)")
+cpp_quote("#define D3D12_FTOI_INSTRUCTION_MAX_INPUT (2147483647.999f)")
+cpp_quote("#define D3D12_FTOI_INSTRUCTION_MIN_INPUT (-2147483648.999f)")
+cpp_quote("#define D3D12_FTOU_INSTRUCTION_MAX_INPUT (4294967295.999f)")
+cpp_quote("#define D3D12_FTOU_INSTRUCTION_MIN_INPUT (0.0f)")
+const UINT D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST = 2;
+const UINT D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS = 1;
+const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = 1;
+const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = 1;
+const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1;
+const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1;
+const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1;
+const UINT D3D12_GS_INPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_GS_INPUT_REGISTER_COUNT = 32;
+const UINT D3D12_GS_INPUT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_GS_INPUT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_GS_INPUT_REGISTER_VERTICES = 32;
+const UINT D3D12_GS_MAX_INSTANCE_COUNT = 32;
+const UINT D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = 1024;
+const UINT D3D12_GS_OUTPUT_ELEMENTS = 32;
+const UINT D3D12_GS_OUTPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_GS_OUTPUT_REGISTER_COUNT = 32;
+const UINT D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = 32;
+const UINT D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = 32;
+const UINT D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xffffffff;
+const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = 1;
+const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = 1;
+const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = 1;
+const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = 1;
+const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = 1;
+const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = 1;
+const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1;
+const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1;
+const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1;
+const UINT D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xffffffff;
+cpp_quote("#define D3D12_HS_MAXTESSFACTOR_LOWER_BOUND (1.0f)")
+cpp_quote("#define D3D12_HS_MAXTESSFACTOR_UPPER_BOUND (64.0f)")
+const UINT D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968;
+const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = 1;
+const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = 1;
+const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = 1;
+const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = 32;
+const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = 128;
+const UINT D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0;
+const UINT D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0;
+const UINT D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0;
+const UINT D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1;
+const UINT D3D12_IA_INSTANCE_ID_BIT_COUNT = 32;
+const UINT D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32;
+const UINT D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32;
+const UINT D3D12_IA_PRIMITIVE_ID_BIT_COUNT = 32;
+const UINT D3D12_IA_VERTEX_ID_BIT_COUNT = 32;
 const UINT D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32;
-const UINT D3D12_UAV_SLOT_COUNT = 64;
+const UINT D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128;
+const UINT D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32;
+const UINT D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff;
+const UINT D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff;
+const UINT D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 0xffffffff;
+const UINT D3D12_KEEP_UNORDERED_ACCESS_VIEWS = 0xffffffff;
+cpp_quote("#define D3D12_LINEAR_GAMMA (1.0f)")
+const UINT D3D12_MAJOR_VERSION = 12;
+cpp_quote("#define D3D12_MAX_BORDER_COLOR_COMPONENT (1.0f)")
+cpp_quote("#define D3D12_MAX_DEPTH (1.0f)")
+const UINT D3D12_MAX_LIVE_STATIC_SAMPLERS = 2032;
+const UINT D3D12_MAX_MAXANISOTROPY = 16;
+const UINT D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT = 32;
+cpp_quote("#define D3D12_MAX_POSITION_VALUE (3.402823466e+34f)")
+const UINT D3D12_MAX_ROOT_COST = 64;
+const UINT D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 = 1000000;
+const UINT D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 = 1000000;
+const UINT D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE = 2048;
+const UINT D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17;
+const UINT D3D12_MAX_VIEW_INSTANCE_COUNT = 4;
+const UINT D3D12_MINOR_VERSION = 0;
+cpp_quote("#define D3D12_MIN_BORDER_COLOR_COMPONENT (0.0f)")
+cpp_quote("#define D3D12_MIN_DEPTH (0.0f)")
+const UINT D3D12_MIN_MAXANISOTROPY = 0;
+cpp_quote("#define D3D12_MIP_LOD_BIAS_MAX (15.99f)")
+cpp_quote("#define D3D12_MIP_LOD_BIAS_MIN (-16.0f)")
+const UINT D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT = 8;
+const UINT D3D12_MIP_LOD_RANGE_BIT_COUNT = 8;
+cpp_quote("#define D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH (1.4f)")
+const UINT D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0;
+const UINT D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END = 0xffffffff;
+const UINT D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff8;
+const UINT D3D12_PACKED_TILE = 0xffffffff;
+const UINT D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15;
+const UINT D3D12_PREVIEW_SDK_VERSION = 702;
+const UINT D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16;
+const UINT D3D12_PS_CS_UAV_REGISTER_COMPONENTS = 1;
+const UINT D3D12_PS_CS_UAV_REGISTER_COUNT = 8;
+const UINT D3D12_PS_CS_UAV_REGISTER_READS_PER_INST = 1;
+const UINT D3D12_PS_CS_UAV_REGISTER_READ_PORTS = 1;
+const UINT D3D12_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff;
+const UINT D3D12_PS_FRONTFACING_FALSE_VALUE = 0x00000000;
+const UINT D3D12_PS_FRONTFACING_TRUE_VALUE = 0xffffffff;
+const UINT D3D12_PS_INPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_PS_INPUT_REGISTER_COUNT = 32;
+const UINT D3D12_PS_INPUT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_PS_INPUT_REGISTER_READ_PORTS = 1;
+cpp_quote("#define D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.0f)")
+const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1;
+const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1;
+const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1;
+const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COUNT = 1;
+const UINT D3D12_PS_OUTPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_PS_OUTPUT_REGISTER_COUNT = 8;
+cpp_quote("#define D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.5f)")
+const UINT D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = 16;
+const UINT D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT = 8;
+const UINT D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT = 256;
+const UINT D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT = 16;
+const UINT D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES = 32;
+const UINT D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH = 31;
+const UINT D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 16777216;
+const UINT D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE = 16777216;
+const UINT D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 536870912;
+const UINT D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS = 1073741824;
+const UINT D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE = 4096;
+const UINT D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT = 32;
+const UINT D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT = 64;
+const UINT D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT = 16;
+const UINT D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096;
+const UINT D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27;
 const UINT D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096;
+const UINT D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096;
+const UINT D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32;
+const UINT D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32;
+const UINT D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384;
+const UINT D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024;
 const UINT D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096;
+const UINT D3D12_REQ_MAXANISOTROPY = 16;
 const UINT D3D12_REQ_MIP_LEVELS = 15;
+const UINT D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048;
+const UINT D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096;
+const UINT D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384;
+const UINT D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128;
+cpp_quote("#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM (0.25f)")
+const UINT D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048;
+const UINT D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20;
+const UINT D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096;
+const UINT D3D12_REQ_SUBRESOURCES = 30720;
 const UINT D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048;
 const UINT D3D12_REQ_TEXTURE1D_U_DIMENSION = 16384;
 const UINT D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048;
 const UINT D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384;
 const UINT D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048;
 const UINT D3D12_REQ_TEXTURECUBE_DIMENSION = 16384;
+const UINT D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0;
 const UINT D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES = 0xffffffff;
+const UINT D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT = 2;
+const UINT D3D12_SDK_VERSION = 602;
+const UINT D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES = 32;
+const UINT D3D12_SHADER_MAJOR_VERSION = 5;
+const UINT D3D12_SHADER_MAX_INSTANCES = 65535;
+const UINT D3D12_SHADER_MAX_INTERFACES = 253;
+const UINT D3D12_SHADER_MAX_INTERFACE_CALL_SITES = 4096;
+const UINT D3D12_SHADER_MAX_TYPES = 65535;
+const UINT D3D12_SHADER_MINOR_VERSION = 1;
+const UINT D3D12_SHIFT_INSTRUCTION_PAD_VALUE = 0;
+const UINT D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5;
 const UINT D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT = 8;
+const UINT D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
+const UINT D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 4096;
 const UINT D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048;
+const UINT D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512;
 const UINT D3D12_SO_BUFFER_SLOT_COUNT = 4;
 const UINT D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff;
 const UINT D3D12_SO_NO_RASTERIZED_STREAM = 0xffffffff;
 const UINT D3D12_SO_OUTPUT_COMPONENT_COUNT = 128;
 const UINT D3D12_SO_STREAM_COUNT = 4;
-const UINT D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = 256;
-const UINT D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 4194304;
-const UINT D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
-const UINT D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = 16;
-const UINT D3D12_SDK_VERSION = 4;
-const UINT D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
-const UINT D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 4096;
+const UINT D3D12_SPEC_DATE_DAY = 14;
+const UINT D3D12_SPEC_DATE_MONTH = 11;
+const UINT D3D12_SPEC_DATE_YEAR = 2014;
+cpp_quote("#define D3D12_SPEC_VERSION (1.16)")
+cpp_quote("#define D3D12_SRGB_GAMMA (2.2f)")
+cpp_quote("#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 (12.92f)")
+cpp_quote("#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 (1.055f)")
+cpp_quote("#define D3D12_SRGB_TO_FLOAT_EXPONENT (2.4f)")
+cpp_quote("#define D3D12_SRGB_TO_FLOAT_OFFSET (0.055f)")
+cpp_quote("#define D3D12_SRGB_TO_FLOAT_THRESHOLD (0.04045f)")
+cpp_quote("#define D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP (0.5f)")
+const UINT D3D12_STANDARD_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64;
 const UINT D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4;
+const UINT D3D12_STANDARD_PIXEL_COMPONENT_COUNT = 128;
+const UINT D3D12_STANDARD_PIXEL_ELEMENT_COUNT = 32;
+const UINT D3D12_STANDARD_VECTOR_SIZE = 4;
+const UINT D3D12_STANDARD_VERTEX_ELEMENT_COUNT = 32;
+const UINT D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64;
+const UINT D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8;
+const UINT D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT = 8;
+const UINT D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END = 0xffffffff;
+const UINT D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff0;
+const UINT D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = 64;
+const UINT D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = 64;
+const UINT D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = 63;
+const UINT D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR = 64;
+const UINT D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = 2;
+const UINT D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = 1;
+const UINT D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = 1;
+const UINT D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT = 16;
 const UINT D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = 256;
 const UINT D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512;
+const UINT D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536;
+const UINT D3D12_TRACKED_WORKLOAD_MAX_INSTANCES = 32;
 const UINT D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT = 4096;
-const UINT D3D12_VS_INPUT_REGISTER_COUNT = 32;
+const UINT D3D12_UAV_SLOT_COUNT = 64;
+const UINT D3D12_UNBOUND_MEMORY_ACCESS_RESULT = 0;
+const UINT D3D12_VIDEO_DECODE_MAX_ARGUMENTS = 10;
+const UINT D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS = 4;
+const UINT D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT = 256;
+const UINT D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT = 256;
+const UINT D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN = 0xffffffff;
+const UINT D3D12_VIDEO_PROCESS_MAX_FILTERS = 32;
+const UINT D3D12_VIDEO_PROCESS_STEREO_VIEWS = 2;
+const UINT D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15;
 const UINT D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16;
+const UINT D3D12_VIEWPORT_BOUNDS_MAX = 32767;
+const INT D3D12_VIEWPORT_BOUNDS_MIN = -32768;
+const UINT D3D12_VS_INPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_VS_INPUT_REGISTER_COUNT = 32;
+const UINT D3D12_VS_INPUT_REGISTER_READS_PER_INST = 2;
+const UINT D3D12_VS_INPUT_REGISTER_READ_PORTS = 1;
+const UINT D3D12_VS_OUTPUT_REGISTER_COMPONENTS = 4;
+const UINT D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
+const UINT D3D12_VS_OUTPUT_REGISTER_COUNT = 32;
+const UINT D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10;
+const UINT D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25;
+const UINT D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25;

cpp_quote("#endif")

@@ -120,6 +490,7 @@ typedef enum D3D12_CROSS_NODE_SHARING_TIER
     D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = 1,
     D3D12_CROSS_NODE_SHARING_TIER_1 = 2,
     D3D12_CROSS_NODE_SHARING_TIER_2 = 3,
+    D3D12_CROSS_NODE_SHARING_TIER_3 = 4,
 } D3D12_CROSS_NODE_SHARING_TIER;

typedef enum D3D12_RESOURCE_HEAP_TIER
@@ -177,6 +548,7 @@ typedef enum D3D12_FORMAT_SUPPORT2
     D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x00000100,
     D3D12_FORMAT_SUPPORT2_TILED = 0x00000200,
     D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x00004000,
+    D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK = 0x00008000,
 } D3D12_FORMAT_SUPPORT2;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT2);")

@@ -201,6 +573,9 @@ typedef enum D3D12_SHADER_CACHE_SUPPORT_FLAGS
     D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 0x2,
     D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4,
     D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8,
+    D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE = 0x10,
+    D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR = 0x20,
+    D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE = 0x40,
 }  D3D12_SHADER_CACHE_SUPPORT_FLAGS;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_SUPPORT_FLAGS);")

@@ -229,8 +604,15 @@ typedef enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER
 {
     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = 0x0,
     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = 0x1,
+    D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2 = 0x2,
 }  D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER;

+typedef struct D3D12_FEATURE_DATA_DISPLAYABLE
+{
+    BOOL DisplayableTexture;
+    D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier;
+} D3D12_FEATURE_DATA_DISPLAYABLE;
+
 typedef enum D3D12_HEAP_SERIALIZATION_TIER
 {
     D3D12_HEAP_SERIALIZATION_TIER_0 = 0x0,
@@ -248,8 +630,16 @@ typedef enum D3D12_RAYTRACING_TIER
 {
     D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0x0,
     D3D12_RAYTRACING_TIER_1_0 = 0xa,
+    D3D12_RAYTRACING_TIER_1_1 = 0xb,
 } D3D12_RAYTRACING_TIER;

+typedef enum D3D12_RESIDENCY_FLAGS
+{
+    D3D12_RESIDENCY_FLAG_NONE = 0x0,
+    D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1,
+} D3D12_RESIDENCY_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESIDENCY_FLAGS);")
+
 interface ID3D12Fence;
 interface ID3D12RootSignature;
 interface ID3D12Heap;
@@ -301,12 +691,26 @@ typedef struct D3D12_SUBRESOURCE_RANGE_UINT64
     D3D12_RANGE_UINT64 Range;
 } D3D12_SUBRESOURCE_RANGE_UINT64;

+typedef struct D3D12_SUBRESOURCE_INFO
+{
+    UINT64 Offset;
+    UINT RowPitch;
+    UINT DepthPitch;
+} D3D12_SUBRESOURCE_INFO;
+
 typedef struct D3D12_RESOURCE_ALLOCATION_INFO
 {
     UINT64 SizeInBytes;
     UINT64 Alignment;
 } D3D12_RESOURCE_ALLOCATION_INFO;

+typedef struct D3D12_RESOURCE_ALLOCATION_INFO1
+{
+    UINT64 Offset;
+    UINT64 Alignment;
+    UINT64 SizeInBytes;
+} D3D12_RESOURCE_ALLOCATION_INFO1;
+
 typedef struct D3D12_DRAW_ARGUMENTS
 {
     UINT VertexCountPerInstance;
@@ -413,6 +817,11 @@ typedef enum D3D12_HEAP_FLAGS
     D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20,
     D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40,
     D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80,
+    D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100,
+    D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200,
+    D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400,
+    D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = 0x800,
+    D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = 0x1000,
     D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0x00,
     D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0,
     D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44,
@@ -507,7 +916,10 @@ typedef enum D3D12_RESOURCE_STATES
     D3D12_RESOURCE_STATE_COPY_SOURCE = 0x800,
     D3D12_RESOURCE_STATE_RESOLVE_DEST = 0x1000,
     D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000,
+    D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000,
+    D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000,
     D3D12_RESOURCE_STATE_GENERIC_READ = 0x1 | 0x2 | 0x40 | 0x80 | 0x200 | 0x800,
+    D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE = 0x40 | 0x80,
     D3D12_RESOURCE_STATE_PRESENT = 0x0,
     D3D12_RESOURCE_STATE_PREDICATION = 0x200,
     D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000,
@@ -591,9 +1003,19 @@ typedef enum D3D12_RESOURCE_FLAGS
     D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8,
     D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10,
     D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20,
+    D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40,
+    D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = 0x80,
+    D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE = 0x100,
 } D3D12_RESOURCE_FLAGS;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_FLAGS);")

+typedef struct D3D12_MIP_REGION
+{
+    UINT Width;
+    UINT Height;
+    UINT Depth;
+} D3D12_MIP_REGION;
+
 typedef struct D3D12_RESOURCE_DESC
 {
     D3D12_RESOURCE_DIMENSION Dimension;
@@ -608,12 +1030,29 @@ typedef struct D3D12_RESOURCE_DESC
     D3D12_RESOURCE_FLAGS Flags;
 } D3D12_RESOURCE_DESC;

+typedef struct D3D12_RESOURCE_DESC1
+{
+    D3D12_RESOURCE_DIMENSION Dimension;
+    UINT64 Alignment;
+    UINT64 Width;
+    UINT Height;
+    UINT16 DepthOrArraySize;
+    UINT16 MipLevels;
+    DXGI_FORMAT Format;
+    DXGI_SAMPLE_DESC SampleDesc;
+    D3D12_TEXTURE_LAYOUT Layout;
+    D3D12_RESOURCE_FLAGS Flags;
+    D3D12_MIP_REGION SamplerFeedbackMipRegion;
+} D3D12_RESOURCE_DESC1;
+
 typedef enum D3D12_RESOLVE_MODE
 {
     D3D12_RESOLVE_MODE_DECOMPRESS = 0,
     D3D12_RESOLVE_MODE_MIN = 1,
     D3D12_RESOLVE_MODE_MAX = 2,
     D3D12_RESOLVE_MODE_AVERAGE = 3,
+    D3D12_RESOLVE_MODE_ENCODE_SAMPLER_FEEDBACK = 4,
+    D3D12_RESOLVE_MODE_DECODE_SAMPLER_FEEDBACK = 5,
 } D3D12_RESOLVE_MODE;

typedef struct D3D12_SAMPLE_POSITION
@@ -678,6 +1117,7 @@ typedef enum D3D12_DESCRIPTOR_RANGE_FLAGS
     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = 0x2,
     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 0x8,
+    D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000,
 } D3D12_DESCRIPTOR_RANGE_FLAGS;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_RANGE_FLAGS);")

@@ -749,6 +1189,8 @@ typedef enum D3D12_SHADER_VISIBILITY
     D3D12_SHADER_VISIBILITY_DOMAIN = 3,
     D3D12_SHADER_VISIBILITY_GEOMETRY = 4,
     D3D12_SHADER_VISIBILITY_PIXEL = 5,
+    D3D12_SHADER_VISIBILITY_AMPLIFICATION = 6,
+    D3D12_SHADER_VISIBILITY_MESH = 7,
 } D3D12_SHADER_VISIBILITY;

typedef struct D3D12_ROOT_PARAMETER
@@ -846,6 +1288,21 @@ typedef enum D3D12_FILTER_REDUCTION_TYPE
 const UINT D3D12_FILTER_REDUCTION_TYPE_MASK = 0x3;
 const UINT D3D12_FILTER_REDUCTION_TYPE_SHIFT = 7;

+cpp_quote("#define D3D12_ENCODE_BASIC_FILTER(min, mag, mip, reduction) \")
+cpp_quote("    ((D3D12_FILTER) ( \")
+cpp_quote("    (((min) & D3D12_FILTER_TYPE_MASK) << D3D12_MIN_FILTER_SHIFT) \")
+cpp_quote("    | (((mag) & D3D12_FILTER_TYPE_MASK) << D3D12_MAG_FILTER_SHIFT) \")
+cpp_quote("    | (((mip) & D3D12_FILTER_TYPE_MASK) << D3D12_MIP_FILTER_SHIFT) \")
+cpp_quote("    | (((reduction) & D3D12_FILTER_REDUCTION_TYPE_MASK) << D3D12_FILTER_REDUCTION_TYPE_SHIFT)))")
+
+cpp_quote("#define D3D12_ENCODE_ANISOTROPIC_FILTER(reduction) \")
+cpp_quote("    ((D3D12_FILTER) ( \")
+cpp_quote("     D3D12_ANISOTROPIC_FILTERING_BIT \")
+cpp_quote("     | D3D12_ENCODE_BASIC_FILTER(D3D12_FILTER_TYPE_LINEAR, \")
+cpp_quote("                                 D3D12_FILTER_TYPE_LINEAR, \")
+cpp_quote("                                 D3D12_FILTER_TYPE_LINEAR, \")
+cpp_quote("                                 reduction)))")
+
 cpp_quote("#define D3D12_DECODE_MAG_FILTER(filter) \")
 cpp_quote("    ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MAG_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))")

@@ -916,6 +1373,11 @@ typedef enum D3D12_ROOT_SIGNATURE_FLAGS
     D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10,
     D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20,
     D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40,
+    D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 0x80,
+    D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 0x100,
+    D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS = 0x200,
+    D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 0x400,
+    D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = 0x800,
 } D3D12_ROOT_SIGNATURE_FLAGS;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_SIGNATURE_FLAGS);")

@@ -999,6 +1461,7 @@ typedef enum D3D12_SRV_DIMENSION
     D3D12_SRV_DIMENSION_TEXTURE3D = 8,
     D3D12_SRV_DIMENSION_TEXTURECUBE = 9,
     D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = 10,
+    D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE = 11,
 } D3D12_SRV_DIMENSION;

typedef enum D3D12_BUFFER_SRV_FLAGS
@@ -1106,6 +1569,11 @@ typedef struct D3D12_TEXCUBE_ARRAY_SRV
     FLOAT ResourceMinLODClamp;
 } D3D12_TEXCUBE_ARRAY_SRV;

+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV
+{
+    D3D12_GPU_VIRTUAL_ADDRESS Location;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV;
+
 typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC
 {
     DXGI_FORMAT Format;
@@ -1123,6 +1591,7 @@ typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC
         D3D12_TEX3D_SRV Texture3D;
         D3D12_TEXCUBE_SRV TextureCube;
         D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray;
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV RaytracingAccelerationStructure;
     };
 } D3D12_SHADER_RESOURCE_VIEW_DESC;

@@ -1413,6 +1882,19 @@ typedef struct D3D12_DEPTH_STENCIL_DESC
     D3D12_DEPTH_STENCILOP_DESC BackFace;
 } D3D12_DEPTH_STENCIL_DESC;

+typedef struct D3D12_DEPTH_STENCIL_DESC1
+{
+    BOOL DepthEnable;
+    D3D12_DEPTH_WRITE_MASK DepthWriteMask;
+    D3D12_COMPARISON_FUNC DepthFunc;
+    BOOL StencilEnable;
+    UINT8 StencilReadMask;
+    UINT8 StencilWriteMask;
+    D3D12_DEPTH_STENCILOP_DESC FrontFace;
+    D3D12_DEPTH_STENCILOP_DESC BackFace;
+    BOOL DepthBoundsTestEnable;
+} D3D12_DEPTH_STENCIL_DESC1;
+
 typedef enum D3D12_BLEND
 {
     D3D12_BLEND_ZERO = 1,
@@ -1432,6 +1914,8 @@ typedef enum D3D12_BLEND
     D3D12_BLEND_INV_SRC1_COLOR = 17,
     D3D12_BLEND_SRC1_ALPHA = 18,
     D3D12_BLEND_INV_SRC1_ALPHA = 19,
+    D3D12_BLEND_ALPHA_FACTOR = 20,
+    D3D12_BLEND_INV_ALPHA_FACTOR = 21,
 } D3D12_BLEND;

typedef enum D3D12_BLEND_OP
@@ -1445,22 +1929,22 @@ typedef enum D3D12_BLEND_OP

typedef enum D3D12_LOGIC_OP
 {
-    D3D12_LOGIC_OP_CLEAR = 0,
-    D3D12_LOGIC_OP_SET = 1,
-    D3D12_LOGIC_OP_COPY = 2,
-    D3D12_LOGIC_OP_COPY_INVERTED = 3,
-    D3D12_LOGIC_OP_NOOP = 4,
-    D3D12_LOGIC_OP_INVERT = 5,
-    D3D12_LOGIC_OP_AND = 6,
-    D3D12_LOGIC_OP_NAND = 7,
-    D3D12_LOGIC_OP_OR = 8,
-    D3D12_LOGIC_OP_NOR = 9,
-    D3D12_LOGIC_OP_XOR = 10,
-    D3D12_LOGIC_OP_EQUIV = 11,
-    D3D12_LOGIC_OP_AND_REVERSE = 12,
-    D3D12_LOGIC_OP_AND_INVERTED = 13,
-    D3D12_LOGIC_OP_OR_REVERSE = 14,
-    D3D12_LOGIC_OP_OR_INVERTED = 15,
+    D3D12_LOGIC_OP_CLEAR = 0x0,
+    D3D12_LOGIC_OP_SET = 0x1,
+    D3D12_LOGIC_OP_COPY = 0x2,
+    D3D12_LOGIC_OP_COPY_INVERTED = 0x3,
+    D3D12_LOGIC_OP_NOOP = 0x4,
+    D3D12_LOGIC_OP_INVERT = 0x5,
+    D3D12_LOGIC_OP_AND = 0x6,
+    D3D12_LOGIC_OP_NAND = 0x7,
+    D3D12_LOGIC_OP_OR = 0x8,
+    D3D12_LOGIC_OP_NOR = 0x9,
+    D3D12_LOGIC_OP_XOR = 0xa,
+    D3D12_LOGIC_OP_EQUIV = 0xb,
+    D3D12_LOGIC_OP_AND_REVERSE = 0xc,
+    D3D12_LOGIC_OP_AND_INVERTED = 0xd,
+    D3D12_LOGIC_OP_OR_REVERSE = 0xe,
+    D3D12_LOGIC_OP_OR_INVERTED = 0xf,
 } D3D12_LOGIC_OP;

typedef enum D3D12_COLOR_WRITE_ENABLE
@@ -1580,6 +2064,8 @@ typedef enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE

typedef D3D_PRIMITIVE_TOPOLOGY D3D12_PRIMITIVE_TOPOLOGY;

+typedef D3D_PRIMITIVE D3D12_PRIMITIVE;
+
 typedef enum D3D12_PRIMITIVE_TOPOLOGY_TYPE
 {
     D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = 0,
@@ -1636,12 +2122,77 @@ typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC
     D3D12_PIPELINE_STATE_FLAGS Flags;
 } D3D12_COMPUTE_PIPELINE_STATE_DESC;

+typedef struct D3D12_PIPELINE_STATE_STREAM_DESC
+{
+    SIZE_T SizeInBytes;
+    void *pPipelineStateSubobjectStream;
+} D3D12_PIPELINE_STATE_STREAM_DESC;
+
+struct D3D12_RT_FORMAT_ARRAY
+{
+    DXGI_FORMAT RTFormats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT];
+    UINT NumRenderTargets;
+};
+
+typedef enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE
+{
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE = 0x0,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS = 0x1,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS = 0x2,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS = 0x3,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS = 0x4,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS = 0x5,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS = 0x6,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = 0x7,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND = 0x8,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = 0x9,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER = 0xa,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = 0xb,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = 0xc,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = 0xd,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = 0xe,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = 0xf,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = 0x10,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = 0x11,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x12,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO = 0x13,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS = 0x14,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = 0x15,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = 0x16,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS = 0x18,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS = 0x19,
+    D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = 0x1a,
+} D3D12_PIPELINE_STATE_SUBOBJECT_TYPE;
+
+typedef struct D3D12_VIEW_INSTANCE_LOCATION
+{
+    UINT ViewportArrayIndex;
+    UINT RenderTargetArrayIndex;
+} D3D12_VIEW_INSTANCE_LOCATION;
+
+typedef enum D3D12_VIEW_INSTANCING_FLAGS
+{
+    D3D12_VIEW_INSTANCING_FLAG_NONE = 0x0,
+    D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 0x1,
+} D3D12_VIEW_INSTANCING_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIEW_INSTANCING_FLAGS);")
+
+typedef struct D3D12_VIEW_INSTANCING_DESC
+{
+    UINT ViewInstanceCount;
+    const D3D12_VIEW_INSTANCE_LOCATION *pViewInstanceLocations;
+    D3D12_VIEW_INSTANCING_FLAGS Flags;
+} D3D12_VIEW_INSTANCING_DESC;
+
 typedef enum D3D12_COMMAND_LIST_TYPE
 {
     D3D12_COMMAND_LIST_TYPE_DIRECT = 0,
     D3D12_COMMAND_LIST_TYPE_BUNDLE = 1,
     D3D12_COMMAND_LIST_TYPE_COMPUTE = 2,
     D3D12_COMMAND_LIST_TYPE_COPY = 3,
+    D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE = 4,
+    D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS = 5,
+    D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE = 6,
 } D3D12_COMMAND_LIST_TYPE;

typedef enum D3D12_COMMAND_QUEUE_PRIORITY
@@ -1702,6 +2253,14 @@ typedef enum D3D_SHADER_MODEL
 {
     D3D_SHADER_MODEL_5_1 = 0x51,
     D3D_SHADER_MODEL_6_0 = 0x60,
+    D3D_SHADER_MODEL_6_1 = 0x61,
+    D3D_SHADER_MODEL_6_2 = 0x62,
+    D3D_SHADER_MODEL_6_3 = 0x63,
+    D3D_SHADER_MODEL_6_4 = 0x64,
+    D3D_SHADER_MODEL_6_5 = 0x65,
+    D3D_SHADER_MODEL_6_6 = 0x66,
+    D3D_SHADER_MODEL_6_7 = 0x67,
+    D3D_HIGHEST_SHADER_MODEL = D3D_SHADER_MODEL_6_7,
 } D3D_SHADER_MODEL;

typedef struct D3D12_FEATURE_DATA_SHADER_MODEL
@@ -1786,6 +2345,107 @@ typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5
     D3D12_RAYTRACING_TIER RaytracingTier;
 } D3D12_FEATURE_DATA_D3D12_OPTIONS5;

+typedef enum D3D12_VARIABLE_SHADING_RATE_TIER
+{
+    D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = 0x0,
+    D3D12_VARIABLE_SHADING_RATE_TIER_1 = 0x1,
+    D3D12_VARIABLE_SHADING_RATE_TIER_2 = 0x2,
+} D3D12_VARIABLE_SHADING_RATE_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS6
+{
+    BOOL AdditionalShadingRatesSupported;
+    BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing;
+    D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier;
+    UINT ShadingRateImageTileSize;
+    BOOL BackgroundProcessingSupported;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS6;
+
+typedef enum D3D12_MESH_SHADER_TIER
+{
+    D3D12_MESH_SHADER_TIER_NOT_SUPPORTED = 0x0,
+    D3D12_MESH_SHADER_TIER_1 = 0xa,
+} D3D12_MESH_SHADER_TIER;
+
+typedef enum D3D12_SAMPLER_FEEDBACK_TIER
+{
+    D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED = 0x0,
+    D3D12_SAMPLER_FEEDBACK_TIER_0_9 = 0x5a,
+    D3D12_SAMPLER_FEEDBACK_TIER_1_0 = 0x64,
+} D3D12_SAMPLER_FEEDBACK_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS7
+{
+    D3D12_MESH_SHADER_TIER MeshShaderTier;
+    D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS7;
+
+typedef struct D3D12_FEATURE_DATA_QUERY_META_COMMAND
+{
+    GUID CommandId;
+    UINT NodeMask;
+    const void *pQueryInputData;
+    SIZE_T QueryInputDataSizeInBytes;
+    void *pQueryOutputData;
+    SIZE_T QueryOutputDataSizeInBytes;
+} D3D12_FEATURE_DATA_QUERY_META_COMMAND;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS8
+{
+    BOOL UnalignedBlockTexturesSupported;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS8;
+
+typedef enum D3D12_WAVE_MMA_TIER
+{
+    D3D12_WAVE_MMA_TIER_NOT_SUPPORTED = 0x0,
+    D3D12_WAVE_MMA_TIER_1_0 = 0xa,
+} D3D12_WAVE_MMA_TIER;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS9
+{
+    BOOL MeshShaderPipelineStatsSupported;
+    BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex;
+    BOOL AtomicInt64OnTypedResourceSupported;
+    BOOL AtomicInt64OnGroupSharedSupported;
+    BOOL DerivativesInMeshAndAmplificationShadersSupported;
+    D3D12_WAVE_MMA_TIER WaveMMATier;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS9;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS10
+{
+    BOOL VariableRateShadingSumCombinerSupported;
+    BOOL MeshShaderPerPrimitiveShadingRateSupported;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS10;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS11
+{
+    BOOL AtomicInt64OnDescriptorHeapResourceSupported;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS11;
+
+typedef enum D3D12_TRI_STATE
+{
+    D3D12_TRI_STATE_UNKNOWN = -0x1,
+    D3D12_TRI_STATE_FALSE = 0x0,
+    D3D12_TRI_STATE_TRUE = 0x1,
+} D3D12_TRI_STATE;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS12
+{
+    D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives;
+    BOOL EnhancedBarriersSupported;
+    BOOL RelaxedFormatCastingSupported;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS12;
+
+typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS13
+{
+    BOOL UnrestrictedBufferTextureCopyPitchSupported;
+    BOOL UnrestrictedVertexElementAlignmentSupported;
+    BOOL InvertedViewportHeightFlipsYSupported;
+    BOOL InvertedViewportDepthFlipsZSupported;
+    BOOL TextureCopyBetweenDimensionsSupported;
+    BOOL AlphaBlendFactorSupported;
+} D3D12_FEATURE_DATA_D3D12_OPTIONS13;
+
 typedef enum D3D12_FEATURE
 {
     D3D12_FEATURE_D3D12_OPTIONS = 0,
@@ -1809,11 +2469,18 @@ typedef enum D3D12_FEATURE
     D3D12_FEATURE_SERIALIZATION = 24,
     D3D12_FEATURE_CROSS_NODE = 25,
     D3D12_FEATURE_D3D12_OPTIONS5 = 27,
+    D3D12_FEATURE_DISPLAYABLE = 28,
     D3D12_FEATURE_D3D12_OPTIONS6 = 30,
     D3D12_FEATURE_QUERY_META_COMMAND = 31,
     D3D12_FEATURE_D3D12_OPTIONS7 = 32,
     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33,
     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES = 34,
+    D3D12_FEATURE_D3D12_OPTIONS8 = 36,
+    D3D12_FEATURE_D3D12_OPTIONS9 = 37,
+    D3D12_FEATURE_D3D12_OPTIONS10 = 39,
+    D3D12_FEATURE_D3D12_OPTIONS11 = 40,
+    D3D12_FEATURE_D3D12_OPTIONS12 = 41,
+    D3D12_FEATURE_D3D12_OPTIONS13 = 42,
 } D3D12_FEATURE;

typedef struct D3D12_MEMCPY_DEST
@@ -1853,6 +2520,24 @@ typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER
     UINT32 Value;
 } D3D12_WRITEBUFFERIMMEDIATE_PARAMETER;

+typedef enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS
+{
+    D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0,
+} D3D12_PROTECTED_RESOURCE_SESSION_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_FLAGS);")
+
+typedef enum D3D12_PROTECTED_SESSION_STATUS
+{
+    D3D12_PROTECTED_SESSION_STATUS_OK = 0,
+    D3D12_PROTECTED_SESSION_STATUS_INVALID = 1,
+} D3D12_PROTECTED_SESSION_STATUS;
+
+typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC
+{
+    UINT NodeMask;
+    D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
+} D3D12_PROTECTED_RESOURCE_SESSION_DESC;
+
 [
     uuid(c4fec28f-7966-4e95-9f94-f431cb56c3b8),
     object,
@@ -1988,6 +2673,8 @@ typedef enum D3D12_QUERY_TYPE
     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5,
     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6,
     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7,
+    D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = 8,
+    D3D12_QUERY_TYPE_PIPELINE_STATISTICS1 = 10,
 } D3D12_QUERY_TYPE;

typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS
@@ -2005,6 +2692,24 @@ typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS
     UINT64 CSInvocations;
 } D3D12_QUERY_DATA_PIPELINE_STATISTICS;

+typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS1
+{
+    UINT64 IAVertices;
+    UINT64 IAPrimitives;
+    UINT64 VSInvocations;
+    UINT64 GSInvocations;
+    UINT64 GSPrimitives;
+    UINT64 CInvocations;
+    UINT64 CPrimitives;
+    UINT64 PSInvocations;
+    UINT64 HSInvocations;
+    UINT64 DSInvocations;
+    UINT64 CSInvocations;
+    UINT64 ASInvocations;
+    UINT64 MSInvocations;
+    UINT64 MSPrimitives;
+} D3D12_QUERY_DATA_PIPELINE_STATISTICS1;
+
 typedef struct D3D12_QUERY_DATA_SO_STATISTICS
 {
     UINT64 NumPrimitivesWritten;
@@ -2214,6 +2919,54 @@ interface ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandList1
             const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes);
 }

+[
+    uuid(a1533d18-0ac1-4084-85b9-89a96116806b),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12ProtectedSession : ID3D12DeviceChild
+{
+    HRESULT GetStatusFence(REFIID riid, void **fence);
+
+    D3D12_PROTECTED_SESSION_STATUS GetSessionStatus();
+}
+
+typedef enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS
+{
+    D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0x0,
+    D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1,
+} D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS);")
+
+typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT
+{
+    UINT NodeIndex;
+    D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support;
+} D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT;
+
+[
+    uuid(6cd696f4-f289-40cc-8091-5a6c0a099c3d),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12ProtectedResourceSession : ID3D12ProtectedSession
+{
+    D3D12_PROTECTED_RESOURCE_SESSION_DESC GetDesc();
+}
+
+[
+    uuid(6fda83a7-b84c-4e38-9ac8-c7bd22016b3d),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandList2
+{
+    void SetProtectedResourceSession(ID3D12ProtectedResourceSession *protected_resource_session);
+}
+
 typedef enum D3D12_TILE_RANGE_FLAGS
 {
     D3D12_TILE_RANGE_FLAG_NONE = 0x0,
@@ -2243,8 +2996,8 @@ interface ID3D12CommandQueue : ID3D12Pageable
             ID3D12Heap *heap,
             UINT range_count,
             const D3D12_TILE_RANGE_FLAGS *range_flags,
-            UINT *heap_range_offsets,
-            UINT *range_tile_counts,
+            const UINT *heap_range_offsets,
+            const UINT *range_tile_counts,
             D3D12_TILE_MAPPING_FLAGS flags);

void CopyTileMappings(ID3D12Resource *dst_resource,
@@ -2275,6 +3028,7 @@ typedef enum D3D12_FENCE_FLAGS
     D3D12_FENCE_FLAG_NONE = 0x0,
     D3D12_FENCE_FLAG_SHARED = 0x1,
     D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2,
+    D3D12_FENCE_FLAG_NON_MONITORED = 0x4,
 } D3D12_FENCE_FLAGS;
 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FENCE_FLAGS);")

@@ -2284,6 +3038,9 @@ typedef enum D3D12_QUERY_HEAP_TYPE
     D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1,
     D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2,
     D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3,
+    D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = 4,
+    D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = 5,
+    D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1 = 7,
 } D3D12_QUERY_HEAP_TYPE;

typedef struct D3D12_QUERY_HEAP_DESC
@@ -2304,6 +3061,8 @@ typedef enum D3D12_INDIRECT_ARGUMENT_TYPE
     D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW,
     D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW,
     D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW,
+    D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS,
+    D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH,
 } D3D12_INDIRECT_ARGUMENT_TYPE;

typedef struct D3D12_INDIRECT_ARGUMENT_DESC
@@ -2378,6 +3137,17 @@ interface ID3D12Fence : ID3D12Pageable
     HRESULT Signal(UINT64 value);
 }

+[
+    uuid(433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Fence1 : ID3D12Fence
+{
+    D3D12_FENCE_FLAGS GetCreationFlags();
+}
+
 [
     uuid(6102dee4-af59-4b09-b999-b44d73f09b24),
     object,
@@ -2517,6 +3287,42 @@ interface ID3D12Device : ID3D12Object
     LUID GetAdapterLuid();
 }

+[
+    uuid(c64226a8-9201-46af-b4cc-53fb9ff7414f),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12PipelineLibrary : ID3D12DeviceChild
+{
+    HRESULT StorePipeline(const WCHAR *name, ID3D12PipelineState *pipeline);
+
+    HRESULT LoadGraphicsPipeline(const WCHAR *name,
+            const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, REFIID riid,
+            void **pipeline_state);
+
+    HRESULT LoadComputePipeline(const WCHAR *name,
+            const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, REFIID riid,
+            void **pipeline_state);
+
+    SIZE_T GetSerializedSize();
+
+    HRESULT Serialize(void *data, SIZE_T data_size_in_bytes);
+}
+
+[
+    uuid(80eabf42-2568-4e5e-bd82-c37f86961dc3),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12PipelineLibrary1 : ID3D12PipelineLibrary
+{
+    HRESULT LoadPipeline(const WCHAR *name,
+            const D3D12_PIPELINE_STATE_STREAM_DESC *desc, REFIID riid,
+            void **pipeline_state);
+}
+
 [
     uuid(77acce80-638e-4e65-8895-c1f23386863e),
     object,
@@ -2534,6 +3340,46 @@ interface ID3D12Device1 : ID3D12Device
             const D3D12_RESIDENCY_PRIORITY *priorities);
 }

+[
+    uuid(30baa41e-b15b-475c-a0bb-1af5c5b64328),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device2 : ID3D12Device1
+{
+    HRESULT CreatePipelineState(
+        [in] const D3D12_PIPELINE_STATE_STREAM_DESC *desc,
+        [in] REFIID riid,
+        [out, iid_is(riid)] void **pipeline_state);
+}
+
+[
+    uuid(81dadc15-2bad-4392-93c5-101345c4aa98),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device3 : ID3D12Device2
+{
+    HRESULT OpenExistingHeapFromAddress(
+        [in] const void *address,
+        [in] REFIID riid,
+        [out, iid_is(riid)] void **heap);
+
+    HRESULT OpenExistingHeapFromFileMapping(
+        [in] HANDLE file_mapping,
+        [in] REFIID riid,
+        [out, iid_is(riid)] void **heap);
+
+    HRESULT EnqueueMakeResident(
+        [in] D3D12_RESIDENCY_FLAGS flags,
+        [in] UINT num_objects,
+        [in] ID3D12Pageable *const *objects,
+        [in] ID3D12Fence *fence,
+        [in] UINT64 fence_value);
+}
+
 [
     uuid(34ab647b-3cc8-46ac-841b-c0965645c046),
     object,
@@ -2559,79 +3405,1587 @@ interface ID3D12VersionedRootSignatureDeserializer : IUnknown
     const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *GetUnconvertedRootSignatureDesc();
 };

-[local] HRESULT __stdcall D3D12CreateRootSignatureDeserializer(
-        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
-
-typedef HRESULT (__stdcall *PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)(
-        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
-
-[local] HRESULT __stdcall D3D12CreateVersionedRootSignatureDeserializer(
-        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
-
-[local] HRESULT __stdcall D3D12SerializeRootSignature(
-        const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
-        D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
-
-typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)(
-        const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob);
-
-[local] HRESULT __stdcall D3D12SerializeVersionedRootSignature(
-        const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *root_signature_desc,
-        ID3DBlob **blob, ID3DBlob **error_blob);
+typedef enum D3D12_COMMAND_LIST_FLAGS
+{
+    D3D12_COMMAND_LIST_FLAG_NONE = 0x0,
+} D3D12_COMMAND_LIST_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_FLAGS);")

-typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter,
-        D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
+typedef enum D3D12_COMMAND_POOL_FLAGS
+{
+    D3D12_COMMAND_POOL_FLAG_NONE = 0x0,
+} D3D12_COMMAND_POOL_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_POOL_FLAGS);")

-[local] HRESULT __stdcall D3D12CreateDevice(IUnknown *adapter,
-        D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
+typedef enum D3D12_COMMAND_RECORDER_FLAGS
+{
+    D3D12_COMMAND_RECORDER_FLAG_NONE = 0x0,
+} D3D12_COMMAND_RECORDER_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_RECORDER_FLAGS);")

-typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug);
+[
+    uuid(e865df17-a9ee-46f9-a463-3098315aa2e5),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device4 : ID3D12Device3
+{
+    HRESULT CreateCommandList1(
+            UINT node_mask, D3D12_COMMAND_LIST_TYPE type,
+            D3D12_COMMAND_LIST_FLAGS flags, REFIID riid,
+            void **command_list);
+
+    HRESULT CreateProtectedResourceSession(
+            const D3D12_PROTECTED_RESOURCE_SESSION_DESC *desc, REFIID riid,
+            void **session);
+
+    HRESULT CreateCommittedResource1(
+            const D3D12_HEAP_PROPERTIES *heap_properties,
+            D3D12_HEAP_FLAGS heap_flags,
+            const D3D12_RESOURCE_DESC *desc,
+            D3D12_RESOURCE_STATES initial_resource_state,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            ID3D12ProtectedResourceSession *protected_session,
+            REFIID riid_resource,
+            void **resource);

-[local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug);
+    HRESULT CreateHeap1(
+            const D3D12_HEAP_DESC *desc,
+            ID3D12ProtectedResourceSession *protected_session,
+            REFIID riid, void **heap);

-[local] HRESULT __stdcall D3D12EnableExperimentalFeatures(UINT feature_count,
-        const IID *iids, void *configurations, UINT *configurations_sizes);
+    HRESULT CreateReservedResource1(
+            const D3D12_RESOURCE_DESC *desc,
+            D3D12_RESOURCE_STATES initial_state,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            ID3D12ProtectedResourceSession *protected_session,
+            REFIID riid, void **resource);

-cpp_quote("DEFINE_GUID(CLSID_D3D12Debug,                     0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f);")
-cpp_quote("DEFINE_GUID(CLSID_D3D12Tools,                     0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8);")
-cpp_quote("DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2);")
-cpp_quote("DEFINE_GUID(CLSID_D3D12SDKConfiguration,          0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce);")
+    D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo1(
+            UINT visible_mask,
+            UINT resource_descs_count,
+            const D3D12_RESOURCE_DESC *resource_descs,
+            D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1);
+}

-typedef enum D3D12_DRED_ENABLEMENT
+typedef enum D3D12_LIFETIME_STATE
 {
-    D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0,
-    D3D12_DRED_ENABLEMENT_FORCED_OFF        = 1,
-    D3D12_DRED_ENABLEMENT_FORCED_ON         = 2,
-} D3D12_DRED_ENABLEMENT;
-
-typedef HRESULT (__stdcall *PFN_D3D12_GET_INTERFACE)(REFCLSID clsid, REFIID iid, void **debug);
-
-[local] HRESULT __stdcall D3D12GetInterface(REFCLSID clsid, REFIID iid, void **debug);
+    D3D12_LIFETIME_STATE_IN_USE = 0x0,
+    D3D12_LIFETIME_STATE_NOT_IN_USE = 0x1,
+} D3D12_LIFETIME_STATE;

[
-    uuid(7071e1f0-e84b-4b33-974f-12fa49de65c5),
+    uuid(e667af9f-cd56-4f46-83ce-032e595d70a8),
     object,
     local,
     pointer_default(unique)
 ]
-interface ID3D12Tools : IUnknown
+interface ID3D12LifetimeOwner : IUnknown
 {
-    void EnableShaderInstrumentation(BOOL enable);
-    BOOL ShaderInstrumentationEnabled();
+    void LifetimeStateUpdated(D3D12_LIFETIME_STATE NewState);
 }

[
-    uuid(82bc481c-6b9b-4030-aedb-7ee3d1df1e63),
+    uuid(f1df64b6-57fd-49cd-8807-c0eb88b45c8f),
     object,
     local,
     pointer_default(unique)
 ]
-interface ID3D12DeviceRemovedExtendedDataSettings : IUnknown
+interface ID3D12SwapChainAssistant : IUnknown
+{
+    LUID GetLUID();
+    HRESULT GetSwapChainObject(REFIID riid, void **ppv);
+    HRESULT GetCurrentResourceAndCommandQueue(
+            REFIID riid_resource, void **resource,
+            REFIID riid_queue, void **queue);
+    HRESULT InsertImplicitSync();
+}
+
+[
+    uuid(3fd03d36-4eb1-424a-a582-494ecb8ba813),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12LifetimeTracker : ID3D12DeviceChild
+{
+    HRESULT DestroyOwnedObject(ID3D12DeviceChild *object);
+}
+
+typedef enum D3D12_META_COMMAND_PARAMETER_TYPE
+{
+    D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = 0x0,
+    D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = 0x1,
+    D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = 0x2,
+    D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x3,
+    D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x4,
+} D3D12_META_COMMAND_PARAMETER_TYPE;
+
+typedef enum D3D12_META_COMMAND_PARAMETER_FLAGS
+{
+    D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 0x1,
+    D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2,
+} D3D12_META_COMMAND_PARAMETER_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_META_COMMAND_PARAMETER_FLAGS);")
+
+typedef enum D3D12_META_COMMAND_PARAMETER_STAGE
+{
+    D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = 0x0,
+    D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = 0x1,
+    D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = 0x2,
+} D3D12_META_COMMAND_PARAMETER_STAGE;
+
+typedef struct D3D12_META_COMMAND_PARAMETER_DESC
+{
+    const WCHAR *Name;
+    D3D12_META_COMMAND_PARAMETER_TYPE Type;
+    D3D12_META_COMMAND_PARAMETER_FLAGS Flags;
+    D3D12_RESOURCE_STATES RequiredResourceState;
+    UINT StructureOffset;
+} D3D12_META_COMMAND_PARAMETER_DESC;
+
+typedef enum D3D12_GRAPHICS_STATES
+{
+    D3D12_GRAPHICS_STATE_NONE = 0x0,
+    D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = 0x1,
+    D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = 0x2,
+    D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = 0x4,
+    D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = 0x8,
+    D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = 0x10,
+    D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = 0x20,
+    D3D12_GRAPHICS_STATE_RS_VIEWPORTS = 0x40,
+    D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = 0x80,
+    D3D12_GRAPHICS_STATE_PREDICATION = 0x100,
+    D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = 0x200,
+    D3D12_GRAPHICS_STATE_OM_STENCIL_REF = 0x400,
+    D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = 0x800,
+    D3D12_GRAPHICS_STATE_PIPELINE_STATE = 0x1000,
+    D3D12_GRAPHICS_STATE_SO_TARGETS = 0x2000,
+    D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = 0x4000,
+    D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = 0x8000,
+    D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = 0x10000,
+} D3D12_GRAPHICS_STATES;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GRAPHICS_STATES);")
+
+typedef struct D3D12_META_COMMAND_DESC
+{
+    GUID Id;
+    const WCHAR *Name;
+    D3D12_GRAPHICS_STATES InitializationDirtyState;
+    D3D12_GRAPHICS_STATES ExecutionDirtyState;
+} D3D12_META_COMMAND_DESC;
+
+[
+    uuid(47016943-fca8-4594-93ea-af258b55346d),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12StateObject : ID3D12Pageable
+{
+}
+
+[
+    uuid(de5fa827-9bf9-4f26-89ff-d7f56fde3860),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12StateObjectProperties : IUnknown
+{
+    void *GetShaderIdentifier(const WCHAR *export_name);
+    UINT64 GetShaderStackSize(const WCHAR *export_name);
+    UINT64 GetPipelineStackSize();
+    void SetPipelineStackSize(UINT64 pipeline_stack_size_in_bytes);
+}
+
+typedef enum D3D12_STATE_SUBOBJECT_TYPE
+{
+    D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0x0,
+    D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 0x1,
+    D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 0x2,
+    D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x3,
+    D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 0x5,
+    D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 0x6,
+    D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x7,
+    D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x8,
+    D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 0x9,
+    D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 0xa,
+    D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 0xb,
+    D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = 0xc,
+    D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = 0xd,
+} D3D12_STATE_SUBOBJECT_TYPE;
+
+typedef struct D3D12_STATE_SUBOBJECT
+{
+    D3D12_STATE_SUBOBJECT_TYPE Type;
+    const void *pDesc;
+} D3D12_STATE_SUBOBJECT;
+
+typedef enum D3D12_STATE_OBJECT_FLAGS
+{
+    D3D12_STATE_OBJECT_FLAG_NONE = 0x0,
+    D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1,
+    D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2,
+    D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4,
+} D3D12_STATE_OBJECT_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_STATE_OBJECT_FLAGS);")
+
+typedef struct D3D12_STATE_OBJECT_CONFIG
+{
+    D3D12_STATE_OBJECT_FLAGS Flags;
+} D3D12_STATE_OBJECT_CONFIG;
+
+typedef struct D3D12_GLOBAL_ROOT_SIGNATURE
+{
+    ID3D12RootSignature *pGlobalRootSignature;
+} D3D12_GLOBAL_ROOT_SIGNATURE;
+
+typedef struct D3D12_LOCAL_ROOT_SIGNATURE
+{
+    ID3D12RootSignature *pLocalRootSignature;
+} D3D12_LOCAL_ROOT_SIGNATURE;
+
+typedef struct D3D12_NODE_MASK
+{
+    UINT NodeMask;
+} D3D12_NODE_MASK;
+
+typedef enum D3D12_EXPORT_FLAGS
+{
+    D3D12_EXPORT_FLAG_NONE = 0x0,
+} D3D12_EXPORT_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_EXPORT_FLAGS);")
+
+typedef struct D3D12_EXPORT_DESC
+{
+    const WCHAR *Name;
+    const WCHAR *ExportToRename;
+    D3D12_EXPORT_FLAGS Flags;
+} D3D12_EXPORT_DESC;
+
+typedef struct D3D12_DXIL_LIBRARY_DESC
+{
+    D3D12_SHADER_BYTECODE DXILLibrary;
+    UINT NumExports;
+    D3D12_EXPORT_DESC *pExports;
+} D3D12_DXIL_LIBRARY_DESC;
+
+typedef struct D3D12_EXISTING_COLLECTION_DESC
+{
+    ID3D12StateObject *pExistingCollection;
+    UINT NumExports;
+    D3D12_EXPORT_DESC *pExports;
+} D3D12_EXISTING_COLLECTION_DESC;
+
+typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+{
+    const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate;
+    UINT NumExports;
+    const WCHAR **pExports;
+} D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+
+typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+{
+    const WCHAR *SubobjectToAssociate;
+    UINT NumExports;
+    const WCHAR **pExports;
+} D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+
+typedef enum D3D12_HIT_GROUP_TYPE
+{
+    D3D12_HIT_GROUP_TYPE_TRIANGLES = 0x0,
+    D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1,
+} D3D12_HIT_GROUP_TYPE;
+
+typedef struct D3D12_HIT_GROUP_DESC
+{
+    const WCHAR *HitGroupExport;
+    D3D12_HIT_GROUP_TYPE Type;
+    const WCHAR *AnyHitShaderImport;
+    const WCHAR *ClosestHitShaderImport;
+    const WCHAR *IntersectionShaderImport;
+} D3D12_HIT_GROUP_DESC;
+
+typedef struct D3D12_RAYTRACING_SHADER_CONFIG
+{
+    UINT MaxPayloadSizeInBytes;
+    UINT MaxAttributeSizeInBytes;
+} D3D12_RAYTRACING_SHADER_CONFIG;
+
+typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG
+{
+    UINT MaxTraceRecursionDepth;
+} D3D12_RAYTRACING_PIPELINE_CONFIG;
+
+typedef enum D3D12_RAYTRACING_PIPELINE_FLAGS
+{
+    D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0x0,
+    D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100,
+    D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200,
+} D3D12_RAYTRACING_PIPELINE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_PIPELINE_FLAGS);")
+
+typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1
+{
+    UINT MaxTraceRecursionDepth;
+    D3D12_RAYTRACING_PIPELINE_FLAGS Flags;
+} D3D12_RAYTRACING_PIPELINE_CONFIG1;
+
+typedef enum D3D12_STATE_OBJECT_TYPE
+{
+    D3D12_STATE_OBJECT_TYPE_COLLECTION = 0x0,
+    D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 0x3,
+} D3D12_STATE_OBJECT_TYPE;
+
+typedef struct D3D12_STATE_OBJECT_DESC
+{
+    D3D12_STATE_OBJECT_TYPE Type;
+    UINT NumSubobjects;
+    const D3D12_STATE_SUBOBJECT *pSubobjects;
+} D3D12_STATE_OBJECT_DESC;
+
+typedef enum D3D12_RAYTRACING_GEOMETRY_FLAGS
+{
+    D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0x0,
+    D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1,
+    D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2,
+} D3D12_RAYTRACING_GEOMETRY_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_GEOMETRY_FLAGS);")
+
+typedef enum D3D12_RAYTRACING_GEOMETRY_TYPE
+{
+    D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0x0,
+    D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = 0x1,
+} D3D12_RAYTRACING_GEOMETRY_TYPE;
+
+typedef enum D3D12_RAYTRACING_INSTANCE_FLAGS
+{
+    D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0x0,
+    D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1,
+    D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2,
+    D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4,
+    D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8
+} D3D12_RAYTRACING_INSTANCE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_INSTANCE_FLAGS);")
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE
+{
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 StrideInBytes;
+} D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE;
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE
+{
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 SizeInBytes;
+} D3D12_GPU_VIRTUAL_ADDRESS_RANGE;
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE
+{
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 SizeInBytes;
+    UINT64 StrideInBytes;
+} D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC
+{
+    D3D12_GPU_VIRTUAL_ADDRESS Transform3x4;
+    DXGI_FORMAT IndexFormat;
+    DXGI_FORMAT VertexFormat;
+    UINT IndexCount;
+    UINT VertexCount;
+    D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer;
+    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer;
+} D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC;
+
+typedef struct D3D12_RAYTRACING_AABB
+{
+    FLOAT MinX;
+    FLOAT MinY;
+    FLOAT MinZ;
+    FLOAT MaxX;
+    FLOAT MaxY;
+    FLOAT MaxZ;
+} D3D12_RAYTRACING_AABB;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC
+{
+    UINT64 AABBCount;
+    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs;
+} D3D12_RAYTRACING_GEOMETRY_AABBS_DESC;
+
+typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS
+{
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0x00,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x01,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x02,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x04,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x08,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20,
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS);")
+
+typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE
+{
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0x0,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4,
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE;
+
+typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE
+{
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0x0,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE;
+
+typedef enum D3D12_ELEMENTS_LAYOUT
+{
+    D3D12_ELEMENTS_LAYOUT_ARRAY = 0x0,
+    D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1
+} D3D12_ELEMENTS_LAYOUT;
+
+typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE
+{
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0x0,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION  = 0x1,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION  = 0x2,
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE  = 0x3,
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC
+{
+    D3D12_GPU_VIRTUAL_ADDRESS DestBuffer;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC
+{
+    UINT64 CompactedSizeInBytes;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC
+{
+    UINT64 DecodedSizeInBytes;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER
+{
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    UINT NumDescs;
+} D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC
+{
+    UINT64 SerializedSizeInBytes;
+    UINT64 NumBottomLevelAccelerationStructurePointers;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC;
+
+typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER
+{
+    GUID DriverOpaqueGUID;
+    BYTE DriverOpaqueVersioningData[16];
+} D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER;
+
+typedef enum D3D12_SERIALIZED_DATA_TYPE
+{
+    D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0x0,
+} D3D12_SERIALIZED_DATA_TYPE;
+
+typedef enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS
+{
+    D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0x0,
+    D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1,
+    D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2,
+    D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3,
+    D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4,
+} D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS;
+
+typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER
+{
+    D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier;
+    UINT64 SerializedSizeInBytesIncludingHeader;
+    UINT64 DeserializedSizeInBytes;
+    UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader;
+} D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC
+{
+    UINT64 CurrentSizeInBytes;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC;
+
+typedef struct D3D12_RAYTRACING_INSTANCE_DESC
+{
+    FLOAT Transform[3][4];
+    UINT InstanceID : 24;
+    UINT InstanceMask : 8;
+    UINT InstanceContributionToHitGroupIndex : 24;
+    UINT Flags : 8;
+    D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure;
+} D3D12_RAYTRACING_INSTANCE_DESC;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_DESC
+{
+    D3D12_RAYTRACING_GEOMETRY_TYPE Type;
+    D3D12_RAYTRACING_GEOMETRY_FLAGS Flags;
+    union
+    {
+        D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles;
+        D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs;
+    };
+} D3D12_RAYTRACING_GEOMETRY_DESC;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS
+{
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags;
+    UINT NumDescs;
+    D3D12_ELEMENTS_LAYOUT DescsLayout;
+    union
+    {
+        D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs;
+    };
+} D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC
+{
+    D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData;
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs;
+    D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData;
+    D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData;
+} D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO
+{
+    UINT64 ResultDataMaxSizeInBytes;
+    UINT64 ScratchDataSizeInBytes;
+    UINT64 UpdateScratchDataSizeInBytes;
+} D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO;
+
+typedef enum D3D12_RAY_FLAGS
+{
+    D3D12_RAY_FLAG_NONE = 0x00,
+    D3D12_RAY_FLAG_FORCE_OPAQUE = 0x01,
+    D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x02,
+    D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x04,
+    D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x08,
+    D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10,
+    D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20,
+    D3D12_RAY_FLAG_CULL_OPAQUE = 0x40,
+    D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80,
+    D3D12_RAY_FLAG_SKIP_TRIANGLES = 0x100,
+    D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200,
+} D3D12_RAY_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAY_FLAGS);")
+
+typedef enum D3D12_HIT_KIND
+{
+    D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe,
+    D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff,
+} D3D12_HIT_KIND;
+
+[
+    uuid(8b4f173b-2fea-4b80-8f58-4307191ab95d),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device5 : ID3D12Device4
+{
+    HRESULT CreateLifetimeTracker(
+            ID3D12LifetimeOwner *owner, REFIID riid,
+            void **tracker);
+
+    void RemoveDevice();
+
+    HRESULT EnumerateMetaCommands(
+            UINT *meta_commands_count,
+            D3D12_META_COMMAND_DESC *descs);
+
+    HRESULT EnumerateMetaCommandParameters(
+            REFGUID command_id,
+            D3D12_META_COMMAND_PARAMETER_STAGE stage,
+            UINT *total_structure_size_in_bytes,
+            UINT *parameter_count,
+            D3D12_META_COMMAND_PARAMETER_DESC *parameter_descs);
+
+    HRESULT CreateMetaCommand(
+            REFGUID command_id, UINT node_mask,
+            const void *creation_parameters_data,
+            SIZE_T creation_parameters_data_size_in_bytes,
+            REFIID riid, void **meta_command);
+
+    HRESULT CreateStateObject(
+            const D3D12_STATE_OBJECT_DESC *desc, REFIID riid,
+            void **state_object);
+
+    void GetRaytracingAccelerationStructurePrebuildInfo(
+            const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *desc,
+            D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *info);
+
+    D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS CheckDriverMatchingIdentifier(
+            D3D12_SERIALIZED_DATA_TYPE serialized_data_type,
+            const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *identifier_to_check);
+}
+
+typedef enum D3D12_AUTO_BREADCRUMB_OP
+{
+    D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0x0,
+    D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 0x1,
+    D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 0x2,
+    D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 0x3,
+    D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 0x4,
+    D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 0x5,
+    D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 0x6,
+    D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 0x7,
+    D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 0x8,
+    D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 0x9,
+    D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 0xa,
+    D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 0xb,
+    D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 0xc,
+    D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 0xd,
+    D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 0xe,
+    D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 0xf,
+    D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 0x10,
+    D3D12_AUTO_BREADCRUMB_OP_PRESENT = 0x11,
+    D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 0x12,
+    D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 0x13,
+    D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 0x14,
+    D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 0x15,
+    D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 0x16,
+    D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 0x17,
+    D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 0x18,
+    D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 0x19,
+    D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 0x1a,
+    D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 0x1b,
+    D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 0x1c,
+    D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 0x1d,
+    D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 0x1e,
+    D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 0x1f,
+    D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 0x20,
+    D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 0x21,
+    D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 0x22,
+    D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 0x23,
+    D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 0x24,
+    D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 0x25,
+    D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 0x26,
+    D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 0x27,
+    D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 0x28,
+    D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 0x29,
+    D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = 0x2a,
+    D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = 0x2b,
+    D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = 0x2c,
+} D3D12_AUTO_BREADCRUMB_OP;
+
+typedef struct D3D12_AUTO_BREADCRUMB_NODE
+{
+    const char *pCommandListDebugNameA;
+    const WCHAR *pCommandListDebugNameW;
+    const char *pCommandQueueDebugNameA;
+    const WCHAR *pCommandQueueDebugNameW;
+    ID3D12GraphicsCommandList *pCommandList;
+    ID3D12CommandQueue *pCommandQueue;
+    UINT32 BreadcrumbCount;
+    const UINT32 *pLastBreadcrumbValue;
+    const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
+    const struct D3D12_AUTO_BREADCRUMB_NODE *pNext;
+} D3D12_AUTO_BREADCRUMB_NODE;
+
+typedef struct D3D12_DRED_BREADCRUMB_CONTEXT
+{
+    UINT BreadcrumbIndex;
+    const WCHAR *pContextString;
+} D3D12_DRED_BREADCRUMB_CONTEXT;
+
+typedef struct D3D12_AUTO_BREADCRUMB_NODE1
+{
+    const char *pCommandListDebugNameA;
+    const WCHAR *pCommandListDebugNameW;
+    const char *pCommandQueueDebugNameA;
+    const WCHAR *pCommandQueueDebugNameW;
+    ID3D12GraphicsCommandList *pCommandList;
+    ID3D12CommandQueue *pCommandQueue;
+    UINT BreadcrumbCount;
+    const UINT *pLastBreadcrumbValue;
+    const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
+    const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext;
+    UINT BreadcrumbContextsCount;
+    D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts;
+} D3D12_AUTO_BREADCRUMB_NODE1;
+
+typedef enum D3D12_DRED_VERSION
+{
+    D3D12_DRED_VERSION_1_0 = 0x1,
+    D3D12_DRED_VERSION_1_1 = 0x2,
+    D3D12_DRED_VERSION_1_2 = 0x3,
+    D3D12_DRED_VERSION_1_3 = 0x4,
+} D3D12_DRED_VERSION;
+
+typedef enum D3D12_DRED_FLAGS
+{
+    D3D12_DRED_FLAG_NONE = 0x0,
+    D3D12_DRED_FLAG_FORCE_ENABLE = 0x1,
+    D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 0x2,
+} D3D12_DRED_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_FLAGS);")
+
+typedef enum D3D12_DRED_ENABLEMENT
+{
+    D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0x0,
+    D3D12_DRED_ENABLEMENT_FORCED_OFF = 0x1,
+    D3D12_DRED_ENABLEMENT_FORCED_ON = 0x2,
+} D3D12_DRED_ENABLEMENT;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA
+{
+    D3D12_DRED_FLAGS Flags;
+    D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
+} D3D12_DEVICE_REMOVED_EXTENDED_DATA;
+
+typedef enum D3D12_DRED_ALLOCATION_TYPE
+{
+    D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 0x13,
+    D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 0x14,
+    D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 0x15,
+    D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 0x16,
+    D3D12_DRED_ALLOCATION_TYPE_FENCE = 0x17,
+    D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 0x18,
+    D3D12_DRED_ALLOCATION_TYPE_HEAP = 0x19,
+    D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 0x1b,
+    D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 0x1c,
+    D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 0x1d,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 0x1e,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 0x20,
+    D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 0x22,
+    D3D12_DRED_ALLOCATION_TYPE_PASS = 0x23,
+    D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 0x24,
+    D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 0x25,
+    D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 0x26,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 0x27,
+    D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 0x28,
+    D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 0x29,
+    D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 0x2a,
+    D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 0x2b,
+    D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 0x2c,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 0x2d,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 0x2e,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 0x2f,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = 0x30,
+    D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = 0x31,
+    D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff,
+} D3D12_DRED_ALLOCATION_TYPE;
+
+typedef struct D3D12_DRED_ALLOCATION_NODE
+{
+    const char *ObjectNameA;
+    const WCHAR *ObjectNameW;
+    D3D12_DRED_ALLOCATION_TYPE AllocationType;
+    const struct D3D12_DRED_ALLOCATION_NODE *pNext;
+} D3D12_DRED_ALLOCATION_NODE;
+
+typedef struct D3D12_DRED_ALLOCATION_NODE1
+{
+    const char *ObjectNameA;
+    const WCHAR *ObjectNameW;
+    D3D12_DRED_ALLOCATION_TYPE AllocationType;
+    const struct D3D12_DRED_ALLOCATION_NODE1 *pNext;
+    const IUnknown *pObject;
+} D3D12_DRED_ALLOCATION_NODE1;
+
+typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT
+{
+    const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
+} D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT;
+
+typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1
+{
+    const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode;
+} D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1;
+
+typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT
+{
+    D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
+    const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode;
+    const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode;
+} D3D12_DRED_PAGE_FAULT_OUTPUT;
+
+typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1
+{
+    D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
+    const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
+    const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
+} D3D12_DRED_PAGE_FAULT_OUTPUT1;
+
+typedef enum D3D12_DRED_PAGE_FAULT_FLAGS
+{
+    D3D12_DRED_PAGE_FAULT_FLAGS_NONE = 0x0,
+} D3D12_DRED_PAGE_FAULT_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_PAGE_FAULT_FLAGS);")
+
+typedef enum D3D12_DRED_DEVICE_STATE
+{
+    D3D12_DRED_DEVICE_STATE_UNKNOWN = 0x0,
+    D3D12_DRED_DEVICE_STATE_HUNG = 0x3,
+    D3D12_DRED_DEVICE_STATE_FAULT = 0x6,
+    D3D12_DRED_DEVICE_STATE_PAGEFAULT = 0x7,
+} D3D12_DRED_DEVICE_STATE;
+
+typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2
+{
+    D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
+    const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
+    const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
+    D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags;
+} D3D12_DRED_PAGE_FAULT_OUTPUT2;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1
+{
+    HRESULT DeviceRemovedReason;
+    D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput;
+    D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput;
+} D3D12_DEVICE_REMOVED_EXTENDED_DATA1;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2
+{
+    HRESULT DeviceRemovedReason;
+    D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
+    D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput;
+} D3D12_DEVICE_REMOVED_EXTENDED_DATA2;
+
+typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3
+{
+    HRESULT DeviceRemovedReason;
+    D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
+    D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput;
+    D3D12_DRED_DEVICE_STATE DeviceState;
+} D3D12_DEVICE_REMOVED_EXTENDED_DATA3;
+
+typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA
+{
+    D3D12_DRED_VERSION Version;
+    union
+    {
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0;
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1;
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2;
+        D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3;
+    };
+} D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA;
+
+[
+    uuid(82bc481c-6b9b-4030-aedb-7ee3d1df1e63),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DeviceRemovedExtendedDataSettings : IUnknown
 {
     void SetAutoBreadcrumbsEnablement(D3D12_DRED_ENABLEMENT enablement);
     void SetPageFaultEnablement(D3D12_DRED_ENABLEMENT enablement);
     void SetWatsonDumpEnablement(D3D12_DRED_ENABLEMENT enablement);
-};
+}
+
+[
+    uuid(dbd5ae51-3317-4f0a-adf9-1d7cedcaae0b),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12DeviceRemovedExtendedDataSettings
+{
+    void SetBreadcrumbContextEnablement(D3D12_DRED_ENABLEMENT enablement);
+}
+
+[
+    uuid(98931d33-5ae8-4791-aa3c-1a73a2934e71),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DeviceRemovedExtendedData : IUnknown
+{
+    HRESULT GetAutoBreadcrumbsOutput(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *output);
+    HRESULT GetPageFaultAllocationOutput(D3D12_DRED_PAGE_FAULT_OUTPUT *output);
+}
+
+[
+    uuid(9727a022-cf1d-4dda-9eba-effa653fc506),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemovedExtendedData
+{
+    HRESULT GetAutoBreadcrumbsOutput1(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *output);
+    HRESULT GetPageFaultAllocationOutput1(D3D12_DRED_PAGE_FAULT_OUTPUT1 *output);
+}
+
+[
+    uuid(67fc5816-e4ca-4915-bf18-42541272da54),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemovedExtendedData1
+{
+    HRESULT GetPageFaultAllocationOutput2(D3D12_DRED_PAGE_FAULT_OUTPUT2 *output);
+    D3D12_DRED_DEVICE_STATE GetDeviceState();
+}
+
+typedef enum D3D12_BACKGROUND_PROCESSING_MODE
+{
+    D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0x0,
+    D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = 0x1,
+    D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = 0x2,
+    D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = 0x3,
+} D3D12_BACKGROUND_PROCESSING_MODE;
+
+typedef enum D3D12_MEASUREMENTS_ACTION
+{
+    D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0x0,
+    D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = 0x1,
+    D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = 0x2,
+    D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = 0x3,
+} D3D12_MEASUREMENTS_ACTION;
+
+[
+    uuid(c70b221b-40e4-4a17-89af-025a0727a6dc),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device6 : ID3D12Device5
+{
+    HRESULT SetBackgroundProcessingMode(
+            D3D12_BACKGROUND_PROCESSING_MODE mode,
+            D3D12_MEASUREMENTS_ACTION action,
+            HANDLE event,
+            BOOL *further_measurements_desired);
+}
+
+cpp_quote("DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED, 0x62b0084e, 0xc70e, 0x4daa, 0xa1, 0x09, 0x30, 0xff, 0x8d, 0x5a, 0x04, 0x82);")
+
+typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT
+{
+    UINT NodeIndex;
+    UINT Count;
+} D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES
+{
+    UINT NodeIndex;
+    UINT Count;
+    GUID *pTypes;
+} D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES;
+
+typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1
+{
+    UINT NodeMask;
+    D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
+    GUID ProtectionType;
+} D3D12_PROTECTED_RESOURCE_SESSION_DESC1;
+
+[
+    uuid(d6f12dd6-76fb-406e-8961-4296eefc0409),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12ProtectedResourceSession1 : ID3D12ProtectedResourceSession
+{
+    D3D12_PROTECTED_RESOURCE_SESSION_DESC1 GetDesc1();
+}
+
+[
+    uuid(5c014b53-68a1-4b9b-8bd1-dd6046b9358b),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device7 : ID3D12Device6
+{
+    HRESULT AddToStateObject(
+            const D3D12_STATE_OBJECT_DESC *addition,
+            ID3D12StateObject *state_object_to_grow_from,
+            REFIID riid, void **new_state_object);
+
+    HRESULT CreateProtectedResourceSession1(
+            const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *desc,
+            REFIID riid, void **session);
+}
+
+[
+    uuid(9218e6bb-f944-4f7e-a75c-b1b2c7b701f3),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device8 : ID3D12Device7
+{
+    D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo2(
+            UINT visible_mask,
+            UINT resource_descs_count,
+            const D3D12_RESOURCE_DESC1 *resource_descs,
+            D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1);
+
+    HRESULT CreateCommittedResource2(
+            const D3D12_HEAP_PROPERTIES *heap_properties,
+            D3D12_HEAP_FLAGS heap_flags,
+            const D3D12_RESOURCE_DESC1 *desc,
+            D3D12_RESOURCE_STATES initial_resource_state,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            ID3D12ProtectedResourceSession *protected_session,
+            REFIID riid_resource, void **resource);
+
+    HRESULT CreatePlacedResource1(
+            ID3D12Heap *heap,
+            UINT64 heap_offset,
+            const D3D12_RESOURCE_DESC1 *desc,
+            D3D12_RESOURCE_STATES initial_state,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            REFIID riid, void **resource);
+
+    void CreateSamplerFeedbackUnorderedAccessView(
+            ID3D12Resource *targeted_resource,
+            ID3D12Resource *feedback_resource,
+            D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor);
+
+    void GetCopyableFootprints1(
+            const D3D12_RESOURCE_DESC1 *resource_desc,
+            UINT first_subresource,
+            UINT subresources_count,
+            UINT64 base_offset,
+            D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts,
+            UINT *rows_count,
+            UINT64 *row_size_in_bytes,
+            UINT64 *total_bytes);
+}
+
+[
+    uuid(9d5e227a-4430-4161-88b3-3eca6bb16e19),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Resource1 : ID3D12Resource
+{
+    HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session);
+}
+
+[
+    uuid(be36ec3b-ea85-4aeb-a45a-e9d76404a495),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Resource2 : ID3D12Resource1
+{
+    D3D12_RESOURCE_DESC1 GetDesc1();
+}
+
+[
+    uuid(572f7389-2168-49e3-9693-d6df5871bf6d),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Heap1 : ID3D12Heap
+{
+    HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session);
+}
+
+typedef enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE
+{
+    D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0x0,
+    D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = 0x1,
+    D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = 0x2,
+    D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = 0x3,
+} D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE;
+
+typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
+{
+    D3D12_CLEAR_VALUE ClearValue;
+} D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS;
+
+typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS
+{
+    D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type;
+
+    union
+    {
+        D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear;
+    };
+} D3D12_RENDER_PASS_BEGINNING_ACCESS;
+
+typedef enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE
+{
+    D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0x0,
+    D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = 0x1,
+    D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = 0x2,
+    D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = 0x3,
+} D3D12_RENDER_PASS_ENDING_ACCESS_TYPE;
+
+typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS
+{
+    UINT SrcSubresource;
+    UINT DstSubresource;
+    UINT DstX;
+    UINT DstY;
+    D3D12_RECT SrcRect;
+} D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS;
+
+typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS
+{
+    ID3D12Resource *pSrcResource;
+    ID3D12Resource *pDstResource;
+    UINT SubresourceCount;
+    const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters;
+    DXGI_FORMAT Format;
+    D3D12_RESOLVE_MODE ResolveMode;
+    BOOL PreserveResolveSource;
+} D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS;
+
+typedef struct D3D12_RENDER_PASS_ENDING_ACCESS
+{
+    D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type;
+    union
+    {
+        D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve;
+    };
+} D3D12_RENDER_PASS_ENDING_ACCESS;
+
+typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC
+{
+    D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
+    D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess;
+    D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess;
+} D3D12_RENDER_PASS_RENDER_TARGET_DESC;
+
+typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC
+{
+    D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
+    D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess;
+    D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess;
+    D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess;
+    D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess;
+} D3D12_RENDER_PASS_DEPTH_STENCIL_DESC;
+
+typedef enum D3D12_RENDER_PASS_FLAGS
+{
+    D3D12_RENDER_PASS_FLAG_NONE = 0x0,
+    D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1,
+    D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2,
+    D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4
+} D3D12_RENDER_PASS_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RENDER_PASS_FLAGS);")
+
+[
+    uuid(dbb84c27-36ce-4fc9-b801-f048c46ac570),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12MetaCommand : ID3D12Pageable
+{
+    UINT64 GetRequiredParameterResourceSize(
+            D3D12_META_COMMAND_PARAMETER_STAGE stage,
+            UINT parameter_index);
+}
+
+typedef struct D3D12_DISPATCH_RAYS_DESC
+{
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable;
+    UINT Width;
+    UINT Height;
+    UINT Depth;
+} D3D12_DISPATCH_RAYS_DESC;
+
+[
+    uuid(8754318e-d3a9-4541-98cf-645b50dc4874),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandList3
+{
+    void BeginRenderPass(
+            UINT render_targets_count,
+            const D3D12_RENDER_PASS_RENDER_TARGET_DESC *render_targets,
+            const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *depth_stencil,
+            D3D12_RENDER_PASS_FLAGS flags);
+
+    void EndRenderPass();
+
+    void InitializeMetaCommand(
+            ID3D12MetaCommand *meta_command,
+            const void *initialization_parameters_data,
+            SIZE_T initialization_parameters_data_size_in_bytes);
+
+    void ExecuteMetaCommand(
+            ID3D12MetaCommand *meta_command,
+            const void *execution_parameters_data,
+            SIZE_T execution_parameters_data_size_in_bytes);
+
+    void BuildRaytracingAccelerationStructure(
+            const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *desc,
+            UINT postbuild_info_descs_count,
+            const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *postbuild_info_descs);
+
+    void EmitRaytracingAccelerationStructurePostbuildInfo(
+            const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *desc,
+            UINT src_acceleration_structures_count,
+            const D3D12_GPU_VIRTUAL_ADDRESS *src_acceleration_structure_data);
+
+    void CopyRaytracingAccelerationStructure(
+            D3D12_GPU_VIRTUAL_ADDRESS dst_acceleration_structure_data,
+            D3D12_GPU_VIRTUAL_ADDRESS src_acceleration_structure_data,
+            D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode);
+
+    void SetPipelineState1(ID3D12StateObject *state_object);
+
+    void DispatchRays(const D3D12_DISPATCH_RAYS_DESC *desc);
+}
+
+typedef enum D3D12_SHADER_CACHE_MODE
+{
+    D3D12_SHADER_CACHE_MODE_MEMORY = 0x0,
+    D3D12_SHADER_CACHE_MODE_DISK = 0x1,
+} D3D12_SHADER_CACHE_MODE;
+
+typedef enum D3D12_SHADER_CACHE_FLAGS
+{
+    D3D12_SHADER_CACHE_FLAG_NONE = 0x0,
+    D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1,
+    D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2,
+} D3D12_SHADER_CACHE_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_FLAGS);")
+
+typedef struct D3D12_SHADER_CACHE_SESSION_DESC
+{
+    GUID Identifier;
+    D3D12_SHADER_CACHE_MODE Mode;
+    D3D12_SHADER_CACHE_FLAGS Flags;
+
+    UINT MaximumInMemoryCacheSizeBytes;
+    UINT MaximumInMemoryCacheEntries;
+
+    UINT MaximumValueFileSizeBytes;
+
+    UINT64 Version;
+} D3D12_SHADER_CACHE_SESSION_DESC;
+
+typedef enum D3D12_BARRIER_LAYOUT
+{
+    D3D12_BARRIER_LAYOUT_UNDEFINED = 0xffffffff,
+    D3D12_BARRIER_LAYOUT_COMMON = 0x0,
+    D3D12_BARRIER_LAYOUT_PRESENT = 0x0,
+    D3D12_BARRIER_LAYOUT_GENERIC_READ = 0x1,
+    D3D12_BARRIER_LAYOUT_RENDER_TARGET = 0x2,
+    D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS = 0x3,
+    D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE = 0x4,
+    D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ = 0x5,
+    D3D12_BARRIER_LAYOUT_SHADER_RESOURCE = 0x6,
+    D3D12_BARRIER_LAYOUT_COPY_SOURCE = 0x7,
+    D3D12_BARRIER_LAYOUT_COPY_DEST = 0x8,
+    D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE = 0x9,
+    D3D12_BARRIER_LAYOUT_RESOLVE_DEST = 0xa,
+    D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE = 0xb,
+    D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ = 0xc,
+    D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE = 0xd,
+    D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ = 0xe,
+    D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE = 0xf,
+    D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ = 0x10,
+    D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE = 0x11,
+    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON = 0x12,
+    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ = 0x13,
+    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS = 0x14,
+    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE = 0x15,
+    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE = 0x16,
+    D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST = 0x17,
+    D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON = 0x18,
+    D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ = 0x19,
+    D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS = 0x1a,
+    D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE = 0x1b,
+    D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE = 0x1c,
+    D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST = 0x1d,
+    D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON = 0x1e,
+} D3D12_BARRIER_LAYOUT;
+
+typedef enum D3D12_BARRIER_SYNC
+{
+    D3D12_BARRIER_SYNC_NONE = 0x0,
+    D3D12_BARRIER_SYNC_ALL = 0x1,
+    D3D12_BARRIER_SYNC_DRAW = 0x2,
+    D3D12_BARRIER_SYNC_INPUT_ASSEMBLER = 0x4,
+    D3D12_BARRIER_SYNC_VERTEX_SHADING = 0x8,
+    D3D12_BARRIER_SYNC_PIXEL_SHADING = 0x10,
+    D3D12_BARRIER_SYNC_DEPTH_STENCIL = 0x20,
+    D3D12_BARRIER_SYNC_RENDER_TARGET = 0x40,
+    D3D12_BARRIER_SYNC_COMPUTE_SHADING = 0x80,
+    D3D12_BARRIER_SYNC_RAYTRACING = 0x100,
+    D3D12_BARRIER_SYNC_COPY = 0x200,
+    D3D12_BARRIER_SYNC_RESOLVE = 0x400,
+    D3D12_BARRIER_SYNC_EXECUTE_INDIRECT = 0x800,
+    D3D12_BARRIER_SYNC_PREDICATION = 0x800,
+    D3D12_BARRIER_SYNC_ALL_SHADING = 0x1000,
+    D3D12_BARRIER_SYNC_NON_PIXEL_SHADING = 0x2000,
+    D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO = 0x4000,
+    D3D12_BARRIER_SYNC_VIDEO_DECODE = 0x100000,
+    D3D12_BARRIER_SYNC_VIDEO_PROCESS = 0x200000,
+    D3D12_BARRIER_SYNC_VIDEO_ENCODE = 0x400000,
+    D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE = 0x800000,
+    D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE = 0x1000000,
+    D3D12_BARRIER_SYNC_SPLIT = 0x80000000,
+} D3D12_BARRIER_SYNC;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_SYNC);")
+
+typedef enum D3D12_BARRIER_ACCESS
+{
+    D3D12_BARRIER_ACCESS_COMMON = 0,
+    D3D12_BARRIER_ACCESS_VERTEX_BUFFER = 0x1,
+    D3D12_BARRIER_ACCESS_CONSTANT_BUFFER = 0x2,
+    D3D12_BARRIER_ACCESS_INDEX_BUFFER = 0x4,
+    D3D12_BARRIER_ACCESS_RENDER_TARGET = 0x8,
+    D3D12_BARRIER_ACCESS_UNORDERED_ACCESS = 0x10,
+    D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE = 0x20,
+    D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ = 0x40,
+    D3D12_BARRIER_ACCESS_SHADER_RESOURCE = 0x80,
+    D3D12_BARRIER_ACCESS_STREAM_OUTPUT = 0x100,
+    D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT = 0x200,
+    D3D12_BARRIER_ACCESS_PREDICATION = 0x200,
+    D3D12_BARRIER_ACCESS_COPY_DEST = 0x400,
+    D3D12_BARRIER_ACCESS_COPY_SOURCE = 0x800,
+    D3D12_BARRIER_ACCESS_RESOLVE_DEST = 0x1000,
+    D3D12_BARRIER_ACCESS_RESOLVE_SOURCE = 0x2000,
+    D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ = 0x4000,
+    D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE = 0x8000,
+    D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE = 0x10000,
+    D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ = 0x20000,
+    D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE = 0x40000,
+    D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ = 0x80000,
+    D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE = 0x100000,
+    D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ = 0x200000,
+    D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE = 0x400000,
+    D3D12_BARRIER_ACCESS_NO_ACCESS = 0x80000000,
+} D3D12_BARRIER_ACCESS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_ACCESS);")
+
+typedef enum D3D12_BARRIER_TYPE
+{
+    D3D12_BARRIER_TYPE_GLOBAL = 0x0,
+    D3D12_BARRIER_TYPE_TEXTURE = 0x1,
+    D3D12_BARRIER_TYPE_BUFFER = 0x2,
+} D3D12_BARRIER_TYPE;
+
+typedef enum D3D12_TEXTURE_BARRIER_FLAGS
+{
+    D3D12_TEXTURE_BARRIER_FLAG_NONE = 0x0,
+    D3D12_TEXTURE_BARRIER_FLAG_DISCARD = 0x1,
+} D3D12_TEXTURE_BARRIER_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TEXTURE_BARRIER_FLAGS);")
+
+typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE
+{
+    UINT IndexOrFirstMipLevel;
+    UINT NumMipLevels;
+    UINT FirstArraySlice;
+    UINT NumArraySlices;
+    UINT FirstPlane;
+    UINT NumPlanes;
+} D3D12_BARRIER_SUBRESOURCE_RANGE;
+
+typedef struct D3D12_GLOBAL_BARRIER
+{
+    D3D12_BARRIER_SYNC SyncBefore;
+    D3D12_BARRIER_SYNC SyncAfter;
+    D3D12_BARRIER_ACCESS AccessBefore;
+    D3D12_BARRIER_ACCESS AccessAfter;
+} D3D12_GLOBAL_BARRIER;
+
+typedef struct D3D12_TEXTURE_BARRIER
+{
+    D3D12_BARRIER_SYNC SyncBefore;
+    D3D12_BARRIER_SYNC SyncAfter;
+    D3D12_BARRIER_ACCESS AccessBefore;
+    D3D12_BARRIER_ACCESS AccessAfter;
+    D3D12_BARRIER_LAYOUT LayoutBefore;
+    D3D12_BARRIER_LAYOUT LayoutAfter;
+    ID3D12Resource *pResource;
+    D3D12_BARRIER_SUBRESOURCE_RANGE Subresources;
+    D3D12_TEXTURE_BARRIER_FLAGS Flags;
+} D3D12_TEXTURE_BARRIER;
+
+typedef struct D3D12_BUFFER_BARRIER
+{
+    D3D12_BARRIER_SYNC SyncBefore;
+    D3D12_BARRIER_SYNC SyncAfter;
+    D3D12_BARRIER_ACCESS AccessBefore;
+    D3D12_BARRIER_ACCESS AccessAfter;
+    ID3D12Resource *pResource;
+    UINT64 Offset;
+    UINT64 Size;
+} D3D12_BUFFER_BARRIER;
+
+typedef struct D3D12_BARRIER_GROUP
+{
+    D3D12_BARRIER_TYPE Type;
+    UINT32 NumBarriers;
+    union
+    {
+        const D3D12_GLOBAL_BARRIER *pGlobalBarriers;
+        const D3D12_TEXTURE_BARRIER *pTextureBarriers;
+        const D3D12_BUFFER_BARRIER *pBufferBarriers;
+    };
+} D3D12_BARRIER_GROUP;
+
+[
+    uuid(28e2495d-0f64-4ae4-a6ec-129255dc49a8),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12ShaderCacheSession : ID3D12DeviceChild
+{
+    HRESULT FindValue(
+            const void *key,
+            UINT key_size,
+            void *value,
+            UINT *value_size);
+    HRESULT StoreValue(
+            const void *key,
+            UINT key_size,
+            const void *value,
+            UINT value_size);
+
+    void SetDeleteOnDestroy();
+    D3D12_SHADER_CACHE_SESSION_DESC GetDesc();
+}
+
+typedef enum D3D12_SHADER_CACHE_KIND_FLAGS
+{
+    D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1,
+    D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2,
+    D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4,
+    D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8,
+} D3D12_SHADER_CACHE_KIND_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_KIND_FLAGS);")
+
+typedef enum D3D12_SHADER_CACHE_CONTROL_FLAGS
+{
+    D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1,
+    D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2,
+    D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4,
+} D3D12_SHADER_CACHE_CONTROL_FLAGS;
+cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_CONTROL_FLAGS);")
+
+[
+    uuid(4c80e962-f032-4f60-bc9e-ebc2cfa1d83c),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device9 : ID3D12Device8
+{
+    HRESULT CreateShaderCacheSession(
+            const D3D12_SHADER_CACHE_SESSION_DESC *desc,
+            REFIID riid, void **session);
+
+    HRESULT ShaderCacheControl(
+            D3D12_SHADER_CACHE_KIND_FLAGS kinds,
+            D3D12_SHADER_CACHE_CONTROL_FLAGS control);
+
+    HRESULT CreateCommandQueue1(
+            const D3D12_COMMAND_QUEUE_DESC *desc,
+            REFIID creator_id,
+            REFIID riid,
+            void **command_queue);
+}
+
+[
+    uuid(517f8718-aa66-49f9-b02b-a7ab89c06031),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Device10 : ID3D12Device9
+{
+    HRESULT CreateCommittedResource3(
+            const D3D12_HEAP_PROPERTIES *heap_properties,
+            D3D12_HEAP_FLAGS heap_flags,
+            const D3D12_RESOURCE_DESC1 *desc,
+            D3D12_BARRIER_LAYOUT initial_layout,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            ID3D12ProtectedResourceSession *protected_session,
+            UINT32 castable_formats_count,
+            DXGI_FORMAT *castable_formats,
+            REFIID riid_resource,
+            void **resource);
+
+    HRESULT CreatePlacedResource2(
+            ID3D12Heap *heap,
+            UINT64 heap_offset,
+            const D3D12_RESOURCE_DESC1 *desc,
+            D3D12_BARRIER_LAYOUT initial_layout,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            UINT32 castable_formats_count,
+            DXGI_FORMAT *castable_formats,
+            REFIID riid,
+            void **resource);
+
+    HRESULT CreateReservedResource2(
+            const D3D12_RESOURCE_DESC *desc,
+            D3D12_BARRIER_LAYOUT initial_layout,
+            const D3D12_CLEAR_VALUE *optimized_clear_value,
+            ID3D12ProtectedResourceSession *protected_session,
+            UINT32 castable_formats_count,
+            DXGI_FORMAT *castable_formats,
+            REFIID riid,
+            void **resource);
+}
+
+[
+    uuid(bc66d368-7373-4943-8757-fc87dc79e476),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12VirtualizationGuestDevice : IUnknown
+{
+    HRESULT ShareWithHost(
+            ID3D12DeviceChild *object,
+            HANDLE *handle);
+
+    HRESULT CreateFenceFd(
+            ID3D12Fence *fence,
+            UINT64 fence_value,
+            int *fence_fd);
+}
+
+[
+    uuid(7071e1f0-e84b-4b33-974f-12fa49de65c5),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12Tools : IUnknown
+{
+    void EnableShaderInstrumentation(BOOL enable);
+    BOOL ShaderInstrumentationEnabled();
+}
+
+cpp_quote("DEFINE_GUID(CLSID_D3D12Debug,                     0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f);")
+cpp_quote("DEFINE_GUID(CLSID_D3D12Tools,                     0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8);")
+cpp_quote("DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2);")
+cpp_quote("DEFINE_GUID(CLSID_D3D12SDKConfiguration,          0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce);")

[
     uuid(e9eb5314-33aa-42b2-a718-d77f58b1f1c7),
@@ -2643,3 +4997,135 @@ interface ID3D12SDKConfiguration : IUnknown
 {
     HRESULT SetSDKVersion(UINT version, const char *path);
 }
+
+typedef enum D3D12_AXIS_SHADING_RATE
+{
+    D3D12_AXIS_SHADING_RATE_1X = 0x0,
+    D3D12_AXIS_SHADING_RATE_2X = 0x1,
+    D3D12_AXIS_SHADING_RATE_4X = 0x2,
+} D3D12_AXIS_SHADING_RATE;
+
+typedef enum D3D12_SHADING_RATE
+{
+    D3D12_SHADING_RATE_1X1 = 0x0,
+    D3D12_SHADING_RATE_1X2 = 0x1,
+    D3D12_SHADING_RATE_2X1 = 0x4,
+    D3D12_SHADING_RATE_2X2 = 0x5,
+    D3D12_SHADING_RATE_2X4 = 0x6,
+    D3D12_SHADING_RATE_4X2 = 0x9,
+    D3D12_SHADING_RATE_4X4 = 0xa,
+} D3D12_SHADING_RATE;
+
+typedef enum D3D12_SHADING_RATE_COMBINER
+{
+    D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0x0,
+    D3D12_SHADING_RATE_COMBINER_OVERRIDE = 0x1,
+    D3D12_SHADING_RATE_COMBINER_MIN = 0x2,
+    D3D12_SHADING_RATE_COMBINER_MAX = 0x3,
+    D3D12_SHADING_RATE_COMBINER_SUM = 0x4,
+} D3D12_SHADING_RATE_COMBINER;
+
+[
+    uuid(55050859-4024-474c-87f5-6472eaee44ea),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandList4
+{
+    void RSSetShadingRate(
+            D3D12_SHADING_RATE base_shading_rate,
+            const D3D12_SHADING_RATE_COMBINER *combiners);
+
+    void RSSetShadingRateImage(
+            ID3D12Resource *shading_rate_image);
+}
+
+const UINT D3D12_SHADING_RATE_X_AXIS_SHIFT = 2;
+const UINT D3D12_SHADING_RATE_VALID_MASK = 3;
+
+cpp_quote("#define D3D12_MAKE_COARSE_SHADING_RATE(x, y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y))")
+cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(val) (((val) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK)")
+cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(val) ((val) & D3D12_SHADING_RATE_VALID_MASK)")
+
+typedef struct D3D12_DISPATCH_MESH_ARGUMENTS
+{
+    UINT ThreadGroupCountX;
+    UINT ThreadGroupCountY;
+    UINT ThreadGroupCountZ;
+} D3D12_DISPATCH_MESH_ARGUMENTS;
+
+[
+    uuid(c3827890-e548-4cfa-96cf-5689a9370f80),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandList5
+{
+    void DispatchMesh(
+            UINT thread_group_count_x,
+            UINT thread_group_count_y,
+            UINT thread_group_count_z);
+}
+
+[
+    uuid(dd171223-8b61-4769-90e3-160ccde4e2c1),
+    object,
+    local,
+    pointer_default(unique)
+]
+interface ID3D12GraphicsCommandList7 : ID3D12GraphicsCommandList6
+{
+    void Barrier(
+            UINT32 barrier_groups_count,
+            const D3D12_BARRIER_GROUP *barrier_groups);
+};
+
+typedef HRESULT (__stdcall *PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)(
+        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
+
+[local] HRESULT __stdcall D3D12CreateRootSignatureDeserializer(
+        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
+
+typedef HRESULT (__stdcall *PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)(
+        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
+
+[local] HRESULT __stdcall D3D12CreateVersionedRootSignatureDeserializer(
+        const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
+
+typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)(
+        const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
+        D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
+
+[local] HRESULT __stdcall D3D12SerializeRootSignature(
+        const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
+        D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
+
+typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)(
+        const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob);
+
+[local] HRESULT __stdcall D3D12SerializeVersionedRootSignature(
+        const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *root_signature_desc,
+        ID3DBlob **blob, ID3DBlob **error_blob);
+
+typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter,
+        D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
+
+[local] HRESULT __stdcall D3D12CreateDevice(IUnknown *adapter,
+        D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
+
+typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug);
+
+[local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug);
+
+[local] HRESULT __stdcall D3D12EnableExperimentalFeatures(UINT feature_count,
+        const IID *iids, void *configurations, UINT *configurations_sizes);
+
+cpp_quote("static const UUID D3D12ExperimentalShaderModels = { 0x76f5573e, 0xf13a, 0x40f5, { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } };")
+cpp_quote("static const UUID D3D12TiledResourceTier4 = { 0xc9c4725f, 0xa81a, 0x4f56, { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } };")
+cpp_quote("static const UUID D3D12MetaCommand = { 0xc734c97e, 0x8077, 0x48c8, { 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77 } };")
+
+typedef HRESULT (__stdcall *PFN_D3D12_GET_INTERFACE)(REFCLSID clsid, REFIID iid, void **debug);
+
+[local] HRESULT __stdcall D3D12GetInterface(REFCLSID clsid, REFIID iid, void **debug);
diff --git a/libs/vkd3d/libs/vkd3d/command.c b/libs/vkd3d/libs/vkd3d/command.c
index 6eddcfa2d14..4e2d4295935 100644
--- a/libs/vkd3d/libs/vkd3d/command.c
+++ b/libs/vkd3d/libs/vkd3d/command.c
@@ -6102,7 +6102,7 @@ static void STDMETHODCALLTYPE d3d12_command_queue_UpdateTileMappings(ID3D12Comma
         ID3D12Resource *resource, UINT region_count,
         const D3D12_TILED_RESOURCE_COORDINATE *region_start_coordinates, const D3D12_TILE_REGION_SIZE *region_sizes,
         ID3D12Heap *heap, UINT range_count, const D3D12_TILE_RANGE_FLAGS *range_flags,
-        UINT *heap_range_offsets, UINT *range_tile_counts, D3D12_TILE_MAPPING_FLAGS flags)
+        const UINT *heap_range_offsets, const UINT *range_tile_counts, D3D12_TILE_MAPPING_FLAGS flags)
 {
     FIXME("iface %p, resource %p, region_count %u, region_start_coordinates %p, "
             "region_sizes %p, heap %p, range_count %u, range_flags %p, heap_range_offsets %p, "