include/d3d12.idl

   1 /*
   2  * Copyright 2016 Józef Kucia for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 import "oaidl.idl";
  20 import "ocidl.idl";
  21 import "dxgi.idl";
  22 import "d3dcommon.idl";
  23
  24 cpp_quote("#ifndef _D3D12_CONSTANTS")
  25 cpp_quote("#define _D3D12_CONSTANTS")
  26
  27 const UINT D3D12_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff;
  28 const UINT D3D12_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff;
  29 const UINT D3D12_8BIT_INDEX_STRIP_CUT_VALUE = 0xff;
  30 const UINT D3D12_APPEND_ALIGNED_ELEMENT = 0xffffffff;
  31 const UINT D3D12_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9;
  32 const UINT D3D12_CLIP_OR_CULL_DISTANCE_COUNT = 8;
  33 const UINT D3D12_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2;
  34 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14;
  35 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4;
  36 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32;
  37 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15;
  38 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16;
  39 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4;
  40 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15;
  41 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1;
  42 const UINT D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1;
  43 const UINT D3D12_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64;
  44 const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4;
  45 const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1;
  46 const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1;
  47 const UINT D3D12_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1;
  48 const UINT D3D12_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32;
  49 const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1;
  50 const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128;
  51 const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1;
  52 const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1;
  53 const UINT D3D12_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128;
  54 const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1;
  55 const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16;
  56 const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1;
  57 const UINT D3D12_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1;
  58 const UINT D3D12_COMMONSHADER_SAMPLER_SLOT_COUNT = 16;
  59 const UINT D3D12_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32;
  60 const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4;
  61 const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32;
  62 const UINT D3D12_COMMONSHADER_TEMP_REGISTER_COUNT = 4096;
  63 const UINT D3D12_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3;
  64 const UINT D3D12_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3;
  65 const UINT D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10;
  66 const INT D3D12_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10;
  67 const INT D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8;
  68 const UINT D3D12_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7;
  69 const UINT D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT = 256;
  70 const UINT D3D12_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256;
  71 const UINT D3D12_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64;
  72 const UINT D3D12_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240;
  73 const UINT D3D12_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68;
  74 const UINT D3D12_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224;
  75 const UINT D3D12_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72;
  76 const UINT D3D12_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208;
  77 const UINT D3D12_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76;
  78 const UINT D3D12_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192;
  79 const UINT D3D12_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84;
  80 const UINT D3D12_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176;
  81 const UINT D3D12_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92;
  82 const UINT D3D12_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160;
  83 const UINT D3D12_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100;
  84 const UINT D3D12_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144;
  85 const UINT D3D12_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112;
  86 const UINT D3D12_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128;
  87 const UINT D3D12_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128;
  88 const UINT D3D12_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112;
  89 const UINT D3D12_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144;
  90 const UINT D3D12_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96;
  91 const UINT D3D12_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168;
  92 const UINT D3D12_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80;
  93 const UINT D3D12_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204;
  94 const UINT D3D12_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64;
  95 const UINT D3D12_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256;
  96 const UINT D3D12_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48;
  97 const UINT D3D12_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340;
  98 const UINT D3D12_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32;
  99 const UINT D3D12_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512;
 100 const UINT D3D12_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16;
 101 const UINT D3D12_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768;
 102 const UINT D3D12_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1;
 103 const UINT D3D12_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256;
 104 const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768;
 105 const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_X = 768;
 106 const UINT D3D12_CS_4_X_THREAD_GROUP_MAX_Y = 768;
 107 const UINT D3D12_CS_4_X_UAV_REGISTER_COUNT = 1;
 108 const UINT D3D12_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535;
 109 const UINT D3D12_CS_TGSM_REGISTER_COUNT = 8192;
 110 const UINT D3D12_CS_TGSM_REGISTER_READS_PER_INST = 1;
 111 const UINT D3D12_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1;
 112 const UINT D3D12_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1;
 113 const UINT D3D12_CS_THREADGROUPID_REGISTER_COMPONENTS = 3;
 114 const UINT D3D12_CS_THREADGROUPID_REGISTER_COUNT = 1;
 115 const UINT D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = 1;
 116 const UINT D3D12_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = 1;
 117 const UINT D3D12_CS_THREADIDINGROUP_REGISTER_COMPONENTS = 3;
 118 const UINT D3D12_CS_THREADIDINGROUP_REGISTER_COUNT = 1;
 119 const UINT D3D12_CS_THREADID_REGISTER_COMPONENTS = 3;
 120 const UINT D3D12_CS_THREADID_REGISTER_COUNT = 1;
 121 const UINT D3D12_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024;
 122 const UINT D3D12_CS_THREAD_GROUP_MAX_X = 1024;
 123 const UINT D3D12_CS_THREAD_GROUP_MAX_Y = 1024;
 124 const UINT D3D12_CS_THREAD_GROUP_MAX_Z = 64;
 125 const UINT D3D12_CS_THREAD_GROUP_MIN_X = 1;
 126 const UINT D3D12_CS_THREAD_GROUP_MIN_Y = 1;
 127 const UINT D3D12_CS_THREAD_GROUP_MIN_Z = 1;
 128 const UINT D3D12_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384;
 129 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_ALPHA (1.0f)")
 130 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_BLUE (1.0f)")
 131 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_GREEN (1.0f)")
 132 cpp_quote("#define D3D12_DEFAULT_BLEND_FACTOR_RED (1.0f)")
 133 cpp_quote("#define D3D12_DEFAULT_BORDER_COLOR_COMPONENT (0.0f)")
 134 const UINT D3D12_DEFAULT_DEPTH_BIAS = 0;
 135 cpp_quote("#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP (0.0f)")
 136 const UINT D3D12_DEFAULT_MAX_ANISOTROPY = 16;
 137 cpp_quote("#define D3D12_DEFAULT_MIP_LOD_BIAS (0.0f)")
 138 const UINT D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 4194304;
 139 const UINT D3D12_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0;
 140 const UINT D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
 141 const UINT D3D12_DEFAULT_SAMPLE_MASK = 0xffffffff;
 142 const UINT D3D12_DEFAULT_SCISSOR_ENDX = 0;
 143 const UINT D3D12_DEFAULT_SCISSOR_ENDY = 0;
 144 const UINT D3D12_DEFAULT_SCISSOR_STARTX = 0;
 145 const UINT D3D12_DEFAULT_SCISSOR_STARTY = 0;
 146 cpp_quote("#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS (0.0f)")
 147 const UINT D3D12_DEFAULT_STENCIL_READ_MASK = 0xff;
 148 const UINT D3D12_DEFAULT_STENCIL_REFERENCE = 0;
 149 const UINT D3D12_DEFAULT_STENCIL_WRITE_MASK = 0xff;
 150 const UINT D3D12_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0;
 151 const UINT D3D12_DEFAULT_VIEWPORT_HEIGHT = 0;
 152 cpp_quote("#define D3D12_DEFAULT_VIEWPORT_MAX_DEPTH (0.0f)")
 153 cpp_quote("#define D3D12_DEFAULT_VIEWPORT_MIN_DEPTH (0.0f)")
 154 const UINT D3D12_DEFAULT_VIEWPORT_TOPLEFTX = 0;
 155 const UINT D3D12_DEFAULT_VIEWPORT_TOPLEFTY = 0;
 156 const UINT D3D12_DEFAULT_VIEWPORT_WIDTH = 0;
 157 const UINT D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND = 0xffffffff;
 158 const UINT D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_END = 0xfffffff7;
 159 const UINT D3D12_DRIVER_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff0;
 160 const UINT D3D12_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968;
 161 const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = 4;
 162 const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
 163 const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = 32;
 164 const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = 2;
 165 const UINT D3D12_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = 1;
 166 const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = 3;
 167 const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
 168 const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = 1;
 169 const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = 2;
 170 const UINT D3D12_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = 1;
 171 const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4;
 172 const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32;
 173 const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = 32;
 174 const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2;
 175 const UINT D3D12_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1;
 176 const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1;
 177 const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
 178 const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1;
 179 const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2;
 180 const UINT D3D12_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1;
 181 const UINT D3D12_DS_OUTPUT_REGISTER_COMPONENTS = 4;
 182 const UINT D3D12_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 183 const UINT D3D12_DS_OUTPUT_REGISTER_COUNT = 32;
 184 cpp_quote("#define D3D12_FLOAT16_FUSED_TOLERANCE_IN_ULP (0.6)")
 185 cpp_quote("#define D3D12_FLOAT32_MAX (3.402823466e+38f)")
 186 cpp_quote("#define D3D12_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP (0.6f)")
 187 cpp_quote("#define D3D12_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR (2.4f)")
 188 cpp_quote("#define D3D12_FLOAT_TO_SRGB_EXPONENT_NUMERATOR (1.0f)")
 189 cpp_quote("#define D3D12_FLOAT_TO_SRGB_OFFSET (0.055f)")
 190 cpp_quote("#define D3D12_FLOAT_TO_SRGB_SCALE_1 (12.92f)")
 191 cpp_quote("#define D3D12_FLOAT_TO_SRGB_SCALE_2 (1.055f)")
 192 cpp_quote("#define D3D12_FLOAT_TO_SRGB_THRESHOLD (0.0031308f)")
 193 cpp_quote("#define D3D12_FTOI_INSTRUCTION_MAX_INPUT (2147483647.999f)")
 194 cpp_quote("#define D3D12_FTOI_INSTRUCTION_MIN_INPUT (-2147483648.999f)")
 195 cpp_quote("#define D3D12_FTOU_INSTRUCTION_MAX_INPUT (4294967295.999f)")
 196 cpp_quote("#define D3D12_FTOU_INSTRUCTION_MIN_INPUT (0.0f)")
 197 const UINT D3D12_GS_INPUT_INSTANCE_ID_READS_PER_INST = 2;
 198 const UINT D3D12_GS_INPUT_INSTANCE_ID_READ_PORTS = 1;
 199 const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = 1;
 200 const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
 201 const UINT D3D12_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = 1;
 202 const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1;
 203 const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32;
 204 const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1;
 205 const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2;
 206 const UINT D3D12_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1;
 207 const UINT D3D12_GS_INPUT_REGISTER_COMPONENTS = 4;
 208 const UINT D3D12_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 209 const UINT D3D12_GS_INPUT_REGISTER_COUNT = 32;
 210 const UINT D3D12_GS_INPUT_REGISTER_READS_PER_INST = 2;
 211 const UINT D3D12_GS_INPUT_REGISTER_READ_PORTS = 1;
 212 const UINT D3D12_GS_INPUT_REGISTER_VERTICES = 32;
 213 const UINT D3D12_GS_MAX_INSTANCE_COUNT = 32;
 214 const UINT D3D12_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = 1024;
 215 const UINT D3D12_GS_OUTPUT_ELEMENTS = 32;
 216 const UINT D3D12_GS_OUTPUT_REGISTER_COMPONENTS = 4;
 217 const UINT D3D12_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 218 const UINT D3D12_GS_OUTPUT_REGISTER_COUNT = 32;
 219 const UINT D3D12_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = 32;
 220 const UINT D3D12_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = 32;
 221 const UINT D3D12_HS_CONTROL_POINT_REGISTER_COMPONENTS = 4;
 222 const UINT D3D12_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
 223 const UINT D3D12_HS_CONTROL_POINT_REGISTER_READS_PER_INST = 2;
 224 const UINT D3D12_HS_CONTROL_POINT_REGISTER_READ_PORTS = 1;
 225 const UINT D3D12_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xffffffff;
 226 const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = 1;
 227 const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
 228 const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = 1;
 229 const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = 2;
 230 const UINT D3D12_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = 1;
 231 const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = 1;
 232 const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
 233 const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = 1;
 234 const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = 2;
 235 const UINT D3D12_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = 1;
 236 const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1;
 237 const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
 238 const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1;
 239 const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2;
 240 const UINT D3D12_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1;
 241 const UINT D3D12_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xffffffff;
 242 cpp_quote("#define D3D12_HS_MAXTESSFACTOR_LOWER_BOUND (1.0f)")
 243 cpp_quote("#define D3D12_HS_MAXTESSFACTOR_UPPER_BOUND (64.0f)")
 244 const UINT D3D12_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968;
 245 const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = 1;
 246 const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
 247 const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = 1;
 248 const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = 2;
 249 const UINT D3D12_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = 1;
 250 const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4;
 251 const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32;
 252 const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = 32;
 253 const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2;
 254 const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1;
 255 const UINT D3D12_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = 128;
 256 const UINT D3D12_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0;
 257 const UINT D3D12_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0;
 258 const UINT D3D12_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0;
 259 const UINT D3D12_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1;
 260 const UINT D3D12_IA_INSTANCE_ID_BIT_COUNT = 32;
 261 const UINT D3D12_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32;
 262 const UINT D3D12_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32;
 263 const UINT D3D12_IA_PRIMITIVE_ID_BIT_COUNT = 32;
 264 const UINT D3D12_IA_VERTEX_ID_BIT_COUNT = 32;
 265 const UINT D3D12_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32;
 266 const UINT D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128;
 267 const UINT D3D12_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32;
 268 const UINT D3D12_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff;
 269 const UINT D3D12_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff;
 270 const UINT D3D12_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 0xffffffff;
 271 const UINT D3D12_KEEP_UNORDERED_ACCESS_VIEWS = 0xffffffff;
 272 cpp_quote("#define D3D12_LINEAR_GAMMA (1.0f)")
 273 const UINT D3D12_MAJOR_VERSION = 12;
 274 cpp_quote("#define D3D12_MAX_BORDER_COLOR_COMPONENT (1.0f)")
 275 cpp_quote("#define D3D12_MAX_DEPTH (1.0f)")
 276 const UINT D3D12_MAX_LIVE_STATIC_SAMPLERS = 2032;
 277 const UINT D3D12_MAX_MAXANISOTROPY = 16;
 278 const UINT D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT = 32;
 279 cpp_quote("#define D3D12_MAX_POSITION_VALUE (3.402823466e+34f)")
 280 const UINT D3D12_MAX_ROOT_COST = 64;
 281 const UINT D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1 = 1000000;
 282 const UINT D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_2 = 1000000;
 283 const UINT D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE = 2048;
 284 const UINT D3D12_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17;
 285 const UINT D3D12_MAX_VIEW_INSTANCE_COUNT = 4;
 286 const UINT D3D12_MINOR_VERSION = 0;
 287 cpp_quote("#define D3D12_MIN_BORDER_COLOR_COMPONENT (0.0f)")
 288 cpp_quote("#define D3D12_MIN_DEPTH (0.0f)")
 289 const UINT D3D12_MIN_MAXANISOTROPY = 0;
 290 cpp_quote("#define D3D12_MIP_LOD_BIAS_MAX (15.99f)")
 291 cpp_quote("#define D3D12_MIP_LOD_BIAS_MIN (-16.0f)")
 292 const UINT D3D12_MIP_LOD_FRACTIONAL_BIT_COUNT = 8;
 293 const UINT D3D12_MIP_LOD_RANGE_BIT_COUNT = 8;
 294 cpp_quote("#define D3D12_MULTISAMPLE_ANTIALIAS_LINE_WIDTH (1.4f)")
 295 const UINT D3D12_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0;
 296 const UINT D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_END = 0xffffffff;
 297 const UINT D3D12_OS_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff8;
 298 const UINT D3D12_PACKED_TILE = 0xffffffff;
 299 const UINT D3D12_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15;
 300 const UINT D3D12_PREVIEW_SDK_VERSION = 702;
 301 const UINT D3D12_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16;
 302 const UINT D3D12_PS_CS_UAV_REGISTER_COMPONENTS = 1;
 303 const UINT D3D12_PS_CS_UAV_REGISTER_COUNT = 8;
 304 const UINT D3D12_PS_CS_UAV_REGISTER_READS_PER_INST = 1;
 305 const UINT D3D12_PS_CS_UAV_REGISTER_READ_PORTS = 1;
 306 const UINT D3D12_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff;
 307 const UINT D3D12_PS_FRONTFACING_FALSE_VALUE = 0x00000000;
 308 const UINT D3D12_PS_FRONTFACING_TRUE_VALUE = 0xffffffff;
 309 const UINT D3D12_PS_INPUT_REGISTER_COMPONENTS = 4;
 310 const UINT D3D12_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 311 const UINT D3D12_PS_INPUT_REGISTER_COUNT = 32;
 312 const UINT D3D12_PS_INPUT_REGISTER_READS_PER_INST = 2;
 313 const UINT D3D12_PS_INPUT_REGISTER_READ_PORTS = 1;
 314 cpp_quote("#define D3D12_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.0f)")
 315 const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1;
 316 const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32;
 317 const UINT D3D12_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1;
 318 const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1;
 319 const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32;
 320 const UINT D3D12_PS_OUTPUT_MASK_REGISTER_COUNT = 1;
 321 const UINT D3D12_PS_OUTPUT_REGISTER_COMPONENTS = 4;
 322 const UINT D3D12_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 323 const UINT D3D12_PS_OUTPUT_REGISTER_COUNT = 8;
 324 cpp_quote("#define D3D12_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT (0.5f)")
 325 const UINT D3D12_RAW_UAV_SRV_BYTE_ALIGNMENT = 16;
 326 const UINT D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT = 8;
 327 const UINT D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT = 256;
 328 const UINT D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT = 16;
 329 const UINT D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES = 32;
 330 const UINT D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH = 31;
 331 const UINT D3D12_RAYTRACING_MAX_GEOMETRIES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 16777216;
 332 const UINT D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE = 16777216;
 333 const UINT D3D12_RAYTRACING_MAX_PRIMITIVES_PER_BOTTOM_LEVEL_ACCELERATION_STRUCTURE = 536870912;
 334 const UINT D3D12_RAYTRACING_MAX_RAY_GENERATION_SHADER_THREADS = 1073741824;
 335 const UINT D3D12_RAYTRACING_MAX_SHADER_RECORD_STRIDE = 4096;
 336 const UINT D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT = 32;
 337 const UINT D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT = 64;
 338 const UINT D3D12_RAYTRACING_TRANSFORM3X4_BYTE_ALIGNMENT = 16;
 339 const UINT D3D12_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096;
 340 const UINT D3D12_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27;
 341 const UINT D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096;
 342 const UINT D3D12_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096;
 343 const UINT D3D12_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32;
 344 const UINT D3D12_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32;
 345 const UINT D3D12_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384;
 346 const UINT D3D12_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024;
 347 const UINT D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096;
 348 const UINT D3D12_REQ_MAXANISOTROPY = 16;
 349 const UINT D3D12_REQ_MIP_LEVELS = 15;
 350 const UINT D3D12_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048;
 351 const UINT D3D12_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096;
 352 const UINT D3D12_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384;
 353 const UINT D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128;
 354 cpp_quote("#define D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM (0.25f)")
 355 const UINT D3D12_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048;
 356 const UINT D3D12_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20;
 357 const UINT D3D12_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096;
 358 const UINT D3D12_REQ_SUBRESOURCES = 30720;
 359 const UINT D3D12_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048;
 360 const UINT D3D12_REQ_TEXTURE1D_U_DIMENSION = 16384;
 361 const UINT D3D12_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048;
 362 const UINT D3D12_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384;
 363 const UINT D3D12_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048;
 364 const UINT D3D12_REQ_TEXTURECUBE_DIMENSION = 16384;
 365 const UINT D3D12_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0;
 366 const UINT D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES = 0xffffffff;
 367 const UINT D3D12_RS_SET_SHADING_RATE_COMBINER_COUNT = 2;
 368 const UINT D3D12_SDK_VERSION = 602;
 369 const UINT D3D12_SHADER_IDENTIFIER_SIZE_IN_BYTES = 32;
 370 const UINT D3D12_SHADER_MAJOR_VERSION = 5;
 371 const UINT D3D12_SHADER_MAX_INSTANCES = 65535;
 372 const UINT D3D12_SHADER_MAX_INTERFACES = 253;
 373 const UINT D3D12_SHADER_MAX_INTERFACE_CALL_SITES = 4096;
 374 const UINT D3D12_SHADER_MAX_TYPES = 65535;
 375 const UINT D3D12_SHADER_MINOR_VERSION = 1;
 376 const UINT D3D12_SHIFT_INSTRUCTION_PAD_VALUE = 0;
 377 const UINT D3D12_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5;
 378 const UINT D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT = 8;
 379 const UINT D3D12_SMALL_MSAA_RESOURCE_PLACEMENT_ALIGNMENT = 65536;
 380 const UINT D3D12_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 4096;
 381 const UINT D3D12_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048;
 382 const UINT D3D12_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512;
 383 const UINT D3D12_SO_BUFFER_SLOT_COUNT = 4;
 384 const UINT D3D12_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff;
 385 const UINT D3D12_SO_NO_RASTERIZED_STREAM = 0xffffffff;
 386 const UINT D3D12_SO_OUTPUT_COMPONENT_COUNT = 128;
 387 const UINT D3D12_SO_STREAM_COUNT = 4;
 388 const UINT D3D12_SPEC_DATE_DAY = 14;
 389 const UINT D3D12_SPEC_DATE_MONTH = 11;
 390 const UINT D3D12_SPEC_DATE_YEAR = 2014;
 391 cpp_quote("#define D3D12_SPEC_VERSION (1.16)")
 392 cpp_quote("#define D3D12_SRGB_GAMMA (2.2f)")
 393 cpp_quote("#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_1 (12.92f)")
 394 cpp_quote("#define D3D12_SRGB_TO_FLOAT_DENOMINATOR_2 (1.055f)")
 395 cpp_quote("#define D3D12_SRGB_TO_FLOAT_EXPONENT (2.4f)")
 396 cpp_quote("#define D3D12_SRGB_TO_FLOAT_OFFSET (0.055f)")
 397 cpp_quote("#define D3D12_SRGB_TO_FLOAT_THRESHOLD (0.04045f)")
 398 cpp_quote("#define D3D12_SRGB_TO_FLOAT_TOLERANCE_IN_ULP (0.5f)")
 399 const UINT D3D12_STANDARD_COMPONENT_BIT_COUNT = 32;
 400 const UINT D3D12_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64;
 401 const UINT D3D12_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4;
 402 const UINT D3D12_STANDARD_PIXEL_COMPONENT_COUNT = 128;
 403 const UINT D3D12_STANDARD_PIXEL_ELEMENT_COUNT = 32;
 404 const UINT D3D12_STANDARD_VECTOR_SIZE = 4;
 405 const UINT D3D12_STANDARD_VERTEX_ELEMENT_COUNT = 32;
 406 const UINT D3D12_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64;
 407 const UINT D3D12_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8;
 408 const UINT D3D12_SUBTEXEL_FRACTIONAL_BIT_COUNT = 8;
 409 const UINT D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_END = 0xffffffff;
 410 const UINT D3D12_SYSTEM_RESERVED_REGISTER_SPACE_VALUES_START = 0xfffffff0;
 411 const UINT D3D12_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = 64;
 412 const UINT D3D12_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = 64;
 413 const UINT D3D12_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = 63;
 414 const UINT D3D12_TESSELLATOR_MAX_TESSELLATION_FACTOR = 64;
 415 const UINT D3D12_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = 2;
 416 const UINT D3D12_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = 1;
 417 const UINT D3D12_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = 1;
 418 const UINT D3D12_TEXEL_ADDRESS_RANGE_BIT_COUNT = 16;
 419 const UINT D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = 256;
 420 const UINT D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512;
 421 const UINT D3D12_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536;
 422 const UINT D3D12_TRACKED_WORKLOAD_MAX_INSTANCES = 32;
 423 const UINT D3D12_UAV_COUNTER_PLACEMENT_ALIGNMENT = 4096;
 424 const UINT D3D12_UAV_SLOT_COUNT = 64;
 425 const UINT D3D12_UNBOUND_MEMORY_ACCESS_RESULT = 0;
 426 const UINT D3D12_VIDEO_DECODE_MAX_ARGUMENTS = 10;
 427 const UINT D3D12_VIDEO_DECODE_MAX_HISTOGRAM_COMPONENTS = 4;
 428 const UINT D3D12_VIDEO_DECODE_MIN_BITSTREAM_OFFSET_ALIGNMENT = 256;
 429 const UINT D3D12_VIDEO_DECODE_MIN_HISTOGRAM_OFFSET_ALIGNMENT = 256;
 430 const UINT D3D12_VIDEO_DECODE_STATUS_MACROBLOCKS_AFFECTED_UNKNOWN = 0xffffffff;
 431 const UINT D3D12_VIDEO_PROCESS_MAX_FILTERS = 32;
 432 const UINT D3D12_VIDEO_PROCESS_STEREO_VIEWS = 2;
 433 const UINT D3D12_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15;
 434 const UINT D3D12_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16;
 435 const UINT D3D12_VIEWPORT_BOUNDS_MAX = 32767;
 436 const INT D3D12_VIEWPORT_BOUNDS_MIN = -32768;
 437 const UINT D3D12_VS_INPUT_REGISTER_COMPONENTS = 4;
 438 const UINT D3D12_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 439 const UINT D3D12_VS_INPUT_REGISTER_COUNT = 32;
 440 const UINT D3D12_VS_INPUT_REGISTER_READS_PER_INST = 2;
 441 const UINT D3D12_VS_INPUT_REGISTER_READ_PORTS = 1;
 442 const UINT D3D12_VS_OUTPUT_REGISTER_COMPONENTS = 4;
 443 const UINT D3D12_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
 444 const UINT D3D12_VS_OUTPUT_REGISTER_COUNT = 32;
 445 const UINT D3D12_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10;
 446 const UINT D3D12_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25;
 447 const UINT D3D12_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25;
 448
 449 cpp_quote("#endif")
 450
 451 const UINT D3D12_SHADER_COMPONENT_MAPPING_MASK = 0x7;
 452 const UINT D3D12_SHADER_COMPONENT_MAPPING_SHIFT = 3;
 453 const UINT D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES
 454         = 1 << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 4);
 455
 456 typedef enum D3D12_SHADER_MIN_PRECISION_SUPPORT
 457 {
 458     D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = 0x0,
 459     D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = 0x1,
 460     D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2,
 461 } D3D12_SHADER_MIN_PRECISION_SUPPORT;
 462 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_MIN_PRECISION_SUPPORT);")
 463
 464 typedef enum D3D12_TILED_RESOURCES_TIER
 465 {
 466     D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED = 0,
 467     D3D12_TILED_RESOURCES_TIER_1 = 1,
 468     D3D12_TILED_RESOURCES_TIER_2 = 2,
 469     D3D12_TILED_RESOURCES_TIER_3 = 3,
 470 } D3D12_TILED_RESOURCES_TIER;
 471
 472 typedef enum D3D12_RESOURCE_BINDING_TIER
 473 {
 474     D3D12_RESOURCE_BINDING_TIER_1 = 1,
 475     D3D12_RESOURCE_BINDING_TIER_2 = 2,
 476     D3D12_RESOURCE_BINDING_TIER_3 = 3,
 477 } D3D12_RESOURCE_BINDING_TIER;
 478
 479 typedef enum D3D12_CONSERVATIVE_RASTERIZATION_TIER
 480 {
 481     D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED = 0,
 482     D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 = 1,
 483     D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 = 2,
 484     D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 = 3,
 485 } D3D12_CONSERVATIVE_RASTERIZATION_TIER;
 486
 487 typedef enum D3D12_CROSS_NODE_SHARING_TIER
 488 {
 489     D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED = 0,
 490     D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = 1,
 491     D3D12_CROSS_NODE_SHARING_TIER_1 = 2,
 492     D3D12_CROSS_NODE_SHARING_TIER_2 = 3,
 493     D3D12_CROSS_NODE_SHARING_TIER_3 = 4,
 494 } D3D12_CROSS_NODE_SHARING_TIER;
 495
 496 typedef enum D3D12_RESOURCE_HEAP_TIER
 497 {
 498     D3D12_RESOURCE_HEAP_TIER_1 = 1,
 499     D3D12_RESOURCE_HEAP_TIER_2 = 2,
 500 } D3D12_RESOURCE_HEAP_TIER;
 501
 502 typedef enum D3D12_FORMAT_SUPPORT1
 503 {
 504     D3D12_FORMAT_SUPPORT1_NONE = 0x00000000,
 505     D3D12_FORMAT_SUPPORT1_BUFFER = 0x00000001,
 506     D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER = 0x00000002,
 507     D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER = 0x00000004,
 508     D3D12_FORMAT_SUPPORT1_SO_BUFFER = 0x00000008,
 509     D3D12_FORMAT_SUPPORT1_TEXTURE1D = 0x00000010,
 510     D3D12_FORMAT_SUPPORT1_TEXTURE2D = 0x00000020,
 511     D3D12_FORMAT_SUPPORT1_TEXTURE3D = 0x00000040,
 512     D3D12_FORMAT_SUPPORT1_TEXTURECUBE = 0x00000080,
 513     D3D12_FORMAT_SUPPORT1_SHADER_LOAD = 0x00000100,
 514     D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE = 0x00000200,
 515     D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON = 0x00000400,
 516     D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT = 0x00000800,
 517     D3D12_FORMAT_SUPPORT1_MIP = 0x00001000,
 518     D3D12_FORMAT_SUPPORT1_RENDER_TARGET = 0x00004000,
 519     D3D12_FORMAT_SUPPORT1_BLENDABLE = 0x00008000,
 520     D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL = 0x00010000,
 521     D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE = 0x00040000,
 522     D3D12_FORMAT_SUPPORT1_DISPLAY = 0x00080000,
 523     D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT = 0x00100000,
 524     D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET = 0x00200000,
 525     D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD = 0x00400000,
 526     D3D12_FORMAT_SUPPORT1_SHADER_GATHER = 0x00800000,
 527     D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST = 0x01000000,
 528     D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW = 0x02000000,
 529     D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON = 0x04000000,
 530     D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT = 0x08000000,
 531     D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT = 0x10000000,
 532     D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = 0x20000000,
 533     D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000,
 534 } D3D12_FORMAT_SUPPORT1;
 535 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT1);")
 536
 537 typedef enum D3D12_FORMAT_SUPPORT2
 538 {
 539     D3D12_FORMAT_SUPPORT2_NONE = 0x00000000,
 540     D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x00000001,
 541     D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x00000002,
 542     D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x00000004,
 543     D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x00000008,
 544     D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x00000010,
 545     D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x00000020,
 546     D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x00000040,
 547     D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x00000080,
 548     D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x00000100,
 549     D3D12_FORMAT_SUPPORT2_TILED = 0x00000200,
 550     D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x00004000,
 551     D3D12_FORMAT_SUPPORT2_SAMPLER_FEEDBACK = 0x00008000,
 552 } D3D12_FORMAT_SUPPORT2;
 553 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FORMAT_SUPPORT2);")
 554
 555 typedef enum D3D12_WRITEBUFFERIMMEDIATE_MODE
 556 {
 557     D3D12_WRITEBUFFERIMMEDIATE_MODE_DEFAULT = 0x0,
 558     D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_IN = 0x1,
 559     D3D12_WRITEBUFFERIMMEDIATE_MODE_MARKER_OUT = 0x2,
 560 } D3D12_WRITEBUFFERIMMEDIATE_MODE;
 561
 562 typedef enum D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER
 563 {
 564     D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED = 0x0,
 565     D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_1 = 0x1,
 566     D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_2 = 0x2,
 567 }  D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER;
 568
 569 typedef enum D3D12_SHADER_CACHE_SUPPORT_FLAGS
 570 {
 571     D3D12_SHADER_CACHE_SUPPORT_NONE = 0x0,
 572     D3D12_SHADER_CACHE_SUPPORT_SINGLE_PSO = 0x1,
 573     D3D12_SHADER_CACHE_SUPPORT_LIBRARY = 0x2,
 574     D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_INPROC_CACHE = 0x4,
 575     D3D12_SHADER_CACHE_SUPPORT_AUTOMATIC_DISK_CACHE = 0x8,
 576     D3D12_SHADER_CACHE_SUPPORT_DRIVER_MANAGED_CACHE = 0x10,
 577     D3D12_SHADER_CACHE_SUPPORT_SHADER_CONTROL_CLEAR = 0x20,
 578     D3D12_SHADER_CACHE_SUPPORT_SHADER_SESSION_DELETE = 0x40,
 579 }  D3D12_SHADER_CACHE_SUPPORT_FLAGS;
 580 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_SUPPORT_FLAGS);")
 581
 582 typedef enum D3D12_COMMAND_LIST_SUPPORT_FLAGS
 583 {
 584     D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE = 0x0,
 585     D3D12_COMMAND_LIST_SUPPORT_FLAG_DIRECT = 0x1,
 586     D3D12_COMMAND_LIST_SUPPORT_FLAG_BUNDLE = 0x2,
 587     D3D12_COMMAND_LIST_SUPPORT_FLAG_COMPUTE = 0x4,
 588     D3D12_COMMAND_LIST_SUPPORT_FLAG_COPY = 0x8,
 589     D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_DECODE = 0x10,
 590     D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_PROCESS = 0x20,
 591     D3D12_COMMAND_LIST_SUPPORT_FLAG_VIDEO_ENCODE = 0x40,
 592 } D3D12_COMMAND_LIST_SUPPORT_FLAGS;
 593 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_SUPPORT_FLAGS);")
 594
 595 typedef enum D3D12_VIEW_INSTANCING_TIER
 596 {
 597     D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED = 0x0,
 598     D3D12_VIEW_INSTANCING_TIER_1 = 0x1,
 599     D3D12_VIEW_INSTANCING_TIER_2 = 0x2,
 600     D3D12_VIEW_INSTANCING_TIER_3 = 0x3,
 601 }  D3D12_VIEW_INSTANCING_TIER;
 602
 603 typedef enum D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER
 604 {
 605     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0 = 0x0,
 606     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_1 = 0x1,
 607     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_2 = 0x2,
 608 }  D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER;
 609
 610 typedef struct D3D12_FEATURE_DATA_DISPLAYABLE
 611 {
 612     BOOL DisplayableTexture;
 613     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier;
 614 } D3D12_FEATURE_DATA_DISPLAYABLE;
 615
 616 typedef enum D3D12_HEAP_SERIALIZATION_TIER
 617 {
 618     D3D12_HEAP_SERIALIZATION_TIER_0 = 0x0,
 619     D3D12_HEAP_SERIALIZATION_TIER_10 = 0xa,
 620 }  D3D12_HEAP_SERIALIZATION_TIER;
 621
 622 typedef enum D3D12_RENDER_PASS_TIER
 623 {
 624     D3D12_RENDER_PASS_TIER_0 = 0x0,
 625     D3D12_RENDER_PASS_TIER_1 = 0x1,
 626     D3D12_RENDER_PASS_TIER_2 = 0x2,
 627 } D3D12_RENDER_PASS_TIER;
 628
 629 typedef enum D3D12_RAYTRACING_TIER
 630 {
 631     D3D12_RAYTRACING_TIER_NOT_SUPPORTED = 0x0,
 632     D3D12_RAYTRACING_TIER_1_0 = 0xa,
 633     D3D12_RAYTRACING_TIER_1_1 = 0xb,
 634 } D3D12_RAYTRACING_TIER;
 635
 636 typedef enum D3D12_RESIDENCY_FLAGS
 637 {
 638     D3D12_RESIDENCY_FLAG_NONE = 0x0,
 639     D3D12_RESIDENCY_FLAG_DENY_OVERBUDGET = 0x1,
 640 } D3D12_RESIDENCY_FLAGS;
 641 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESIDENCY_FLAGS);")
 642
 643 interface ID3D12Fence;
 644 interface ID3D12RootSignature;
 645 interface ID3D12Heap;
 646 interface ID3D12DescriptorHeap;
 647 interface ID3D12Resource;
 648 interface ID3D12CommandAllocator;
 649 interface ID3D12GraphicsCommandList;
 650 interface ID3D12CommandQueue;
 651 interface ID3D12PipelineState;
 652 interface ID3D12Device;
 653
 654 typedef RECT D3D12_RECT;
 655
 656 typedef struct D3D12_BOX
 657 {
 658     UINT left;
 659     UINT top;
 660     UINT front;
 661     UINT right;
 662     UINT bottom;
 663     UINT back;
 664 } D3D12_BOX;
 665
 666 typedef struct D3D12_VIEWPORT
 667 {
 668     FLOAT TopLeftX;
 669     FLOAT TopLeftY;
 670     FLOAT Width;
 671     FLOAT Height;
 672     FLOAT MinDepth;
 673     FLOAT MaxDepth;
 674 } D3D12_VIEWPORT;
 675
 676 typedef struct D3D12_RANGE
 677 {
 678     SIZE_T Begin;
 679     SIZE_T End;
 680 } D3D12_RANGE;
 681
 682 typedef struct D3D12_RANGE_UINT64
 683 {
 684     UINT64 Begin;
 685     UINT64 End;
 686 } D3D12_RANGE_UINT64;
 687
 688 typedef struct D3D12_SUBRESOURCE_RANGE_UINT64
 689 {
 690     UINT Subresource;
 691     D3D12_RANGE_UINT64 Range;
 692 } D3D12_SUBRESOURCE_RANGE_UINT64;
 693
 694 typedef struct D3D12_SUBRESOURCE_INFO
 695 {
 696     UINT64 Offset;
 697     UINT RowPitch;
 698     UINT DepthPitch;
 699 } D3D12_SUBRESOURCE_INFO;
 700
 701 typedef struct D3D12_RESOURCE_ALLOCATION_INFO
 702 {
 703     UINT64 SizeInBytes;
 704     UINT64 Alignment;
 705 } D3D12_RESOURCE_ALLOCATION_INFO;
 706
 707 typedef struct D3D12_RESOURCE_ALLOCATION_INFO1
 708 {
 709     UINT64 Offset;
 710     UINT64 Alignment;
 711     UINT64 SizeInBytes;
 712 } D3D12_RESOURCE_ALLOCATION_INFO1;
 713
 714 typedef struct D3D12_DRAW_ARGUMENTS
 715 {
 716     UINT VertexCountPerInstance;
 717     UINT InstanceCount;
 718     UINT StartVertexLocation;
 719     UINT StartInstanceLocation;
 720 } D3D12_DRAW_ARGUMENTS;
 721
 722 typedef struct D3D12_DRAW_INDEXED_ARGUMENTS
 723 {
 724     UINT IndexCountPerInstance;
 725     UINT InstanceCount;
 726     UINT StartIndexLocation;
 727     INT BaseVertexLocation;
 728     UINT StartInstanceLocation;
 729 } D3D12_DRAW_INDEXED_ARGUMENTS;
 730
 731 typedef struct D3D12_DISPATCH_ARGUMENTS
 732 {
 733     UINT ThreadGroupCountX;
 734     UINT ThreadGroupCountY;
 735     UINT ThreadGroupCountZ;
 736 } D3D12_DISPATCH_ARGUMENTS;
 737
 738 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS
 739 {
 740     BOOL DoublePrecisionFloatShaderOps;
 741     BOOL OutputMergerLogicOp;
 742     D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport;
 743     D3D12_TILED_RESOURCES_TIER TiledResourcesTier;
 744     D3D12_RESOURCE_BINDING_TIER ResourceBindingTier;
 745     BOOL PSSpecifiedStencilRefSupported;
 746     BOOL TypedUAVLoadAdditionalFormats;
 747     BOOL ROVsSupported;
 748     D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier;
 749     UINT MaxGPUVirtualAddressBitsPerResource;
 750     BOOL StandardSwizzle64KBSupported;
 751     D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier;
 752     BOOL CrossAdapterRowMajorTextureSupported;
 753     BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation;
 754     D3D12_RESOURCE_HEAP_TIER ResourceHeapTier;
 755 } D3D12_FEATURE_DATA_D3D12_OPTIONS;
 756
 757 typedef struct D3D12_FEATURE_DATA_FORMAT_SUPPORT
 758 {
 759     DXGI_FORMAT Format;
 760     D3D12_FORMAT_SUPPORT1 Support1;
 761     D3D12_FORMAT_SUPPORT2 Support2;
 762 } D3D12_FEATURE_DATA_FORMAT_SUPPORT;
 763
 764 typedef enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS
 765 {
 766     D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0x00000000,
 767     D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x00000001,
 768 } D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS;
 769 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS);")
 770
 771 typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS
 772 {
 773     DXGI_FORMAT Format;
 774     UINT SampleCount;
 775     D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags;
 776     UINT NumQualityLevels;
 777 } D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS;
 778
 779 typedef enum D3D12_HEAP_TYPE
 780 {
 781     D3D12_HEAP_TYPE_DEFAULT = 1,
 782     D3D12_HEAP_TYPE_UPLOAD = 2,
 783     D3D12_HEAP_TYPE_READBACK = 3,
 784     D3D12_HEAP_TYPE_CUSTOM = 4,
 785 } D3D12_HEAP_TYPE;
 786
 787 typedef enum D3D12_CPU_PAGE_PROPERTY
 788 {
 789     D3D12_CPU_PAGE_PROPERTY_UNKNOWN = 0,
 790     D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE = 1,
 791     D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE = 2,
 792     D3D12_CPU_PAGE_PROPERTY_WRITE_BACK = 3,
 793 } D3D12_CPU_PAGE_PROPERTY;
 794
 795 typedef enum D3D12_MEMORY_POOL
 796 {
 797     D3D12_MEMORY_POOL_UNKNOWN = 0,
 798     D3D12_MEMORY_POOL_L0 = 1,
 799     D3D12_MEMORY_POOL_L1 = 2,
 800 } D3D12_MEMORY_POOL;
 801
 802 typedef struct D3D12_HEAP_PROPERTIES
 803 {
 804     D3D12_HEAP_TYPE Type;
 805     D3D12_CPU_PAGE_PROPERTY CPUPageProperty;
 806     D3D12_MEMORY_POOL MemoryPoolPreference;
 807     UINT CreationNodeMask;
 808     UINT VisibleNodeMask;
 809 } D3D12_HEAP_PROPERTIES;
 810
 811 typedef enum D3D12_HEAP_FLAGS
 812 {
 813     D3D12_HEAP_FLAG_NONE = 0x00,
 814     D3D12_HEAP_FLAG_SHARED = 0x01,
 815     D3D12_HEAP_FLAG_DENY_BUFFERS = 0x04,
 816     D3D12_HEAP_FLAG_ALLOW_DISPLAY = 0x08,
 817     D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20,
 818     D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40,
 819     D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80,
 820     D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100,
 821     D3D12_HEAP_FLAG_ALLOW_WRITE_WATCH = 0x200,
 822     D3D12_HEAP_FLAG_ALLOW_SHADER_ATOMICS = 0x400,
 823     D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT = 0x800,
 824     D3D12_HEAP_FLAG_CREATE_NOT_ZEROED = 0x1000,
 825     D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0x00,
 826     D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0,
 827     D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44,
 828     D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84,
 829 } D3D12_HEAP_FLAGS;
 830 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_HEAP_FLAGS);")
 831
 832 typedef struct D3D12_HEAP_DESC
 833 {
 834     UINT64 SizeInBytes;
 835     D3D12_HEAP_PROPERTIES Properties;
 836     UINT64 Alignment;
 837     D3D12_HEAP_FLAGS Flags;
 838 } D3D12_HEAP_DESC;
 839
 840 typedef struct D3D12_TILED_RESOURCE_COORDINATE
 841 {
 842     UINT X;
 843     UINT Y;
 844     UINT Z;
 845     UINT Subresource;
 846 } D3D12_TILED_RESOURCE_COORDINATE;
 847
 848 typedef struct D3D12_TILE_REGION_SIZE
 849 {
 850     UINT NumTiles;
 851     BOOL UseBox;
 852     UINT Width;
 853     UINT16 Height;
 854     UINT16 Depth;
 855 } D3D12_TILE_REGION_SIZE;
 856
 857 typedef struct D3D12_SUBRESOURCE_TILING
 858 {
 859     UINT WidthInTiles;
 860     UINT16 HeightInTiles;
 861     UINT16 DepthInTiles;
 862     UINT StartTileIndexInOverallResource;
 863 } D3D12_SUBRESOURCE_TILING;
 864
 865 typedef struct D3D12_TILE_SHAPE
 866 {
 867     UINT WidthInTexels;
 868     UINT HeightInTexels;
 869     UINT DepthInTexels;
 870 } D3D12_TILE_SHAPE;
 871
 872 typedef struct D3D12_SHADER_BYTECODE
 873 {
 874     const void *pShaderBytecode;
 875     SIZE_T BytecodeLength;
 876 } D3D12_SHADER_BYTECODE;
 877
 878 typedef struct D3D12_DEPTH_STENCIL_VALUE
 879 {
 880     FLOAT Depth;
 881     UINT8 Stencil;
 882 } D3D12_DEPTH_STENCIL_VALUE;
 883
 884 typedef struct D3D12_CLEAR_VALUE
 885 {
 886     DXGI_FORMAT Format;
 887     union
 888     {
 889         FLOAT Color[4];
 890         D3D12_DEPTH_STENCIL_VALUE DepthStencil;
 891     };
 892 } D3D12_CLEAR_VALUE;
 893
 894 typedef struct D3D12_PACKED_MIP_INFO
 895 {
 896     UINT8 NumStandardMips;
 897     UINT8 NumPackedMips;
 898     UINT NumTilesForPackedMips;
 899     UINT StartTileIndexInOverallResource;
 900 } D3D12_PACKED_MIP_INFO;
 901
 902 typedef enum D3D12_RESOURCE_STATES
 903 {
 904     D3D12_RESOURCE_STATE_COMMON = 0,
 905     D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 0x1,
 906     D3D12_RESOURCE_STATE_INDEX_BUFFER = 0x2,
 907     D3D12_RESOURCE_STATE_RENDER_TARGET = 0x4,
 908     D3D12_RESOURCE_STATE_UNORDERED_ACCESS = 0x8,
 909     D3D12_RESOURCE_STATE_DEPTH_WRITE = 0x10,
 910     D3D12_RESOURCE_STATE_DEPTH_READ = 0x20,
 911     D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 0x40,
 912     D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 0x80,
 913     D3D12_RESOURCE_STATE_STREAM_OUT = 0x100,
 914     D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = 0x200,
 915     D3D12_RESOURCE_STATE_COPY_DEST = 0x400,
 916     D3D12_RESOURCE_STATE_COPY_SOURCE = 0x800,
 917     D3D12_RESOURCE_STATE_RESOLVE_DEST = 0x1000,
 918     D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000,
 919     D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE = 0x400000,
 920     D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE = 0x1000000,
 921     D3D12_RESOURCE_STATE_GENERIC_READ = 0x1 | 0x2 | 0x40 | 0x80 | 0x200 | 0x800,
 922     D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE = 0x40 | 0x80,
 923     D3D12_RESOURCE_STATE_PRESENT = 0x0,
 924     D3D12_RESOURCE_STATE_PREDICATION = 0x200,
 925     D3D12_RESOURCE_STATE_VIDEO_DECODE_READ = 0x10000,
 926     D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE = 0x20000,
 927     D3D12_RESOURCE_STATE_VIDEO_PROCESS_READ = 0x40000,
 928     D3D12_RESOURCE_STATE_VIDEO_PROCESS_WRITE = 0x80000,
 929     D3D12_RESOURCE_STATE_VIDEO_ENCODE_READ = 0x200000,
 930     D3D12_RESOURCE_STATE_VIDEO_ENCODE_WRITE = 0x800000,
 931 } D3D12_RESOURCE_STATES;
 932 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_STATES);")
 933
 934 typedef enum D3D12_RESOURCE_BARRIER_TYPE
 935 {
 936     D3D12_RESOURCE_BARRIER_TYPE_TRANSITION = 0,
 937     D3D12_RESOURCE_BARRIER_TYPE_ALIASING = 1,
 938     D3D12_RESOURCE_BARRIER_TYPE_UAV = 2,
 939 } D3D12_RESOURCE_BARRIER_TYPE;
 940
 941 typedef enum D3D12_RESOURCE_BARRIER_FLAGS
 942 {
 943     D3D12_RESOURCE_BARRIER_FLAG_NONE = 0x0,
 944     D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1,
 945     D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2,
 946 } D3D12_RESOURCE_BARRIER_FLAGS;
 947 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_BARRIER_FLAGS);")
 948
 949 typedef struct D3D12_RESOURCE_TRANSITION_BARRIER
 950 {
 951     ID3D12Resource *pResource;
 952     UINT Subresource;
 953     D3D12_RESOURCE_STATES StateBefore;
 954     D3D12_RESOURCE_STATES StateAfter;
 955 } D3D12_RESOURCE_TRANSITION_BARRIER;
 956
 957 typedef struct D3D12_RESOURCE_ALIASING_BARRIER_ALIASING
 958 {
 959     ID3D12Resource *pResourceBefore;
 960     ID3D12Resource *pResourceAfter;
 961 } D3D12_RESOURCE_ALIASING_BARRIER;
 962
 963 typedef struct D3D12_RESOURCE_UAV_BARRIER
 964 {
 965     ID3D12Resource *pResource;
 966 } D3D12_RESOURCE_UAV_BARRIER;
 967
 968 typedef struct D3D12_RESOURCE_BARRIER
 969 {
 970     D3D12_RESOURCE_BARRIER_TYPE Type;
 971     D3D12_RESOURCE_BARRIER_FLAGS Flags;
 972     union
 973     {
 974         D3D12_RESOURCE_TRANSITION_BARRIER Transition;
 975         D3D12_RESOURCE_ALIASING_BARRIER Aliasing;
 976         D3D12_RESOURCE_UAV_BARRIER UAV;
 977     };
 978 } D3D12_RESOURCE_BARRIER;
 979
 980 typedef enum D3D12_RESOURCE_DIMENSION
 981 {
 982     D3D12_RESOURCE_DIMENSION_UNKNOWN = 0,
 983     D3D12_RESOURCE_DIMENSION_BUFFER = 1,
 984     D3D12_RESOURCE_DIMENSION_TEXTURE1D = 2,
 985     D3D12_RESOURCE_DIMENSION_TEXTURE2D = 3,
 986     D3D12_RESOURCE_DIMENSION_TEXTURE3D = 4,
 987 } D3D12_RESOURCE_DIMENSION;
 988
 989 typedef enum D3D12_TEXTURE_LAYOUT
 990 {
 991     D3D12_TEXTURE_LAYOUT_UNKNOWN = 0,
 992     D3D12_TEXTURE_LAYOUT_ROW_MAJOR = 1,
 993     D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE = 2,
 994     D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = 3,
 995 } D3D12_TEXTURE_LAYOUT;
 996
 997 typedef enum D3D12_RESOURCE_FLAGS
 998 {
 999     D3D12_RESOURCE_FLAG_NONE = 0x0,
1000     D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = 0x1,
1001     D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 0x2,
1002     D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 0x4,
1003     D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8,
1004     D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10,
1005     D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20,
1006     D3D12_RESOURCE_FLAG_VIDEO_DECODE_REFERENCE_ONLY = 0x40,
1007     D3D12_RESOURCE_FLAG_VIDEO_ENCODE_REFERENCE_ONLY = 0x80,
1008     D3D12_RESOURCE_FLAG_RAYTRACING_ACCELERATION_STRUCTURE = 0x100,
1009 } D3D12_RESOURCE_FLAGS;
1010 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RESOURCE_FLAGS);")
1011
1012 typedef struct D3D12_MIP_REGION
1013 {
1014     UINT Width;
1015     UINT Height;
1016     UINT Depth;
1017 } D3D12_MIP_REGION;
1018
1019 typedef struct D3D12_RESOURCE_DESC
1020 {
1021     D3D12_RESOURCE_DIMENSION Dimension;
1022     UINT64 Alignment;
1023     UINT64 Width;
1024     UINT Height;
1025     UINT16 DepthOrArraySize;
1026     UINT16 MipLevels;
1027     DXGI_FORMAT Format;
1028     DXGI_SAMPLE_DESC SampleDesc;
1029     D3D12_TEXTURE_LAYOUT Layout;
1030     D3D12_RESOURCE_FLAGS Flags;
1031 } D3D12_RESOURCE_DESC;
1032
1033 typedef struct D3D12_RESOURCE_DESC1
1034 {
1035     D3D12_RESOURCE_DIMENSION Dimension;
1036     UINT64 Alignment;
1037     UINT64 Width;
1038     UINT Height;
1039     UINT16 DepthOrArraySize;
1040     UINT16 MipLevels;
1041     DXGI_FORMAT Format;
1042     DXGI_SAMPLE_DESC SampleDesc;
1043     D3D12_TEXTURE_LAYOUT Layout;
1044     D3D12_RESOURCE_FLAGS Flags;
1045     D3D12_MIP_REGION SamplerFeedbackMipRegion;
1046 } D3D12_RESOURCE_DESC1;
1047
1048 typedef enum D3D12_RESOLVE_MODE
1049 {
1050     D3D12_RESOLVE_MODE_DECOMPRESS = 0,
1051     D3D12_RESOLVE_MODE_MIN = 1,
1052     D3D12_RESOLVE_MODE_MAX = 2,
1053     D3D12_RESOLVE_MODE_AVERAGE = 3,
1054     D3D12_RESOLVE_MODE_ENCODE_SAMPLER_FEEDBACK = 4,
1055     D3D12_RESOLVE_MODE_DECODE_SAMPLER_FEEDBACK = 5,
1056 } D3D12_RESOLVE_MODE;
1057
1058 typedef struct D3D12_SAMPLE_POSITION
1059 {
1060     INT8 X;
1061     INT8 Y;
1062 } D3D12_SAMPLE_POSITION;
1063
1064 typedef enum D3D12_TEXTURE_COPY_TYPE
1065 {
1066     D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX = 0,
1067     D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT = 1,
1068 } D3D12_TEXTURE_COPY_TYPE;
1069
1070 typedef struct D3D12_SUBRESOURCE_FOOTPRINT
1071 {
1072     DXGI_FORMAT Format;
1073     UINT Width;
1074     UINT Height;
1075     UINT Depth;
1076     UINT RowPitch;
1077 } D3D12_SUBRESOURCE_FOOTPRINT;
1078
1079 typedef struct D3D12_PLACED_SUBRESOURCE_FOOTPRINT
1080 {
1081     UINT64 Offset;
1082     D3D12_SUBRESOURCE_FOOTPRINT Footprint;
1083 } D3D12_PLACED_SUBRESOURCE_FOOTPRINT;
1084
1085 typedef struct D3D12_TEXTURE_COPY_LOCATION
1086 {
1087     ID3D12Resource *pResource;
1088     D3D12_TEXTURE_COPY_TYPE Type;
1089     union
1090     {
1091         D3D12_PLACED_SUBRESOURCE_FOOTPRINT PlacedFootprint;
1092         UINT SubresourceIndex;
1093     };
1094 } D3D12_TEXTURE_COPY_LOCATION;
1095
1096 typedef enum D3D12_DESCRIPTOR_RANGE_TYPE
1097 {
1098     D3D12_DESCRIPTOR_RANGE_TYPE_SRV = 0,
1099     D3D12_DESCRIPTOR_RANGE_TYPE_UAV = 1,
1100     D3D12_DESCRIPTOR_RANGE_TYPE_CBV = 2,
1101     D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER = 3,
1102 } D3D12_DESCRIPTOR_RANGE_TYPE;
1103
1104 typedef struct D3D12_DESCRIPTOR_RANGE
1105 {
1106     D3D12_DESCRIPTOR_RANGE_TYPE RangeType;
1107     UINT NumDescriptors;
1108     UINT BaseShaderRegister;
1109     UINT RegisterSpace;
1110     UINT OffsetInDescriptorsFromTableStart;
1111 } D3D12_DESCRIPTOR_RANGE;
1112
1113 typedef enum D3D12_DESCRIPTOR_RANGE_FLAGS
1114 {
1115     D3D12_DESCRIPTOR_RANGE_FLAG_NONE = 0x0,
1116     D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE = 0x1,
1117     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE = 0x2,
1118     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
1119     D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC = 0x8,
1120     D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 0x10000,
1121 } D3D12_DESCRIPTOR_RANGE_FLAGS;
1122 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_RANGE_FLAGS);")
1123
1124 typedef struct D3D12_DESCRIPTOR_RANGE1
1125 {
1126     D3D12_DESCRIPTOR_RANGE_TYPE RangeType;
1127     UINT NumDescriptors;
1128     UINT BaseShaderRegister;
1129     UINT RegisterSpace;
1130     D3D12_DESCRIPTOR_RANGE_FLAGS Flags;
1131     UINT OffsetInDescriptorsFromTableStart;
1132 } D3D12_DESCRIPTOR_RANGE1;
1133
1134 typedef struct D3D12_ROOT_DESCRIPTOR_TABLE
1135 {
1136     UINT NumDescriptorRanges;
1137     const D3D12_DESCRIPTOR_RANGE *pDescriptorRanges;
1138 } D3D12_ROOT_DESCRIPTOR_TABLE;
1139
1140 typedef struct D3D12_ROOT_DESCRIPTOR_TABLE1
1141 {
1142     UINT NumDescriptorRanges;
1143     const D3D12_DESCRIPTOR_RANGE1 *pDescriptorRanges;
1144 } D3D12_ROOT_DESCRIPTOR_TABLE1;
1145
1146 typedef struct D3D12_ROOT_CONSTANTS
1147 {
1148     UINT ShaderRegister;
1149     UINT RegisterSpace;
1150     UINT Num32BitValues;
1151 } D3D12_ROOT_CONSTANTS;
1152
1153 typedef struct D3D12_ROOT_DESCRIPTOR
1154 {
1155     UINT ShaderRegister;
1156     UINT RegisterSpace;
1157 } D3D12_ROOT_DESCRIPTOR;
1158
1159 typedef enum D3D12_ROOT_DESCRIPTOR_FLAGS
1160 {
1161     D3D12_ROOT_DESCRIPTOR_FLAG_NONE = 0x0,
1162     D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE = 0x2,
1163     D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC_WHILE_SET_AT_EXECUTE = 0x4,
1164     D3D12_ROOT_DESCRIPTOR_FLAG_DATA_STATIC = 0x8,
1165 } D3D12_ROOT_DESCRIPTOR_FLAGS;
1166 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_DESCRIPTOR_FLAGS);")
1167
1168 typedef struct D3D12_ROOT_DESCRIPTOR1
1169 {
1170     UINT ShaderRegister;
1171     UINT RegisterSpace;
1172     D3D12_ROOT_DESCRIPTOR_FLAGS Flags;
1173 } D3D12_ROOT_DESCRIPTOR1;
1174
1175 typedef enum D3D12_ROOT_PARAMETER_TYPE
1176 {
1177     D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE = 0,
1178     D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS = 1,
1179     D3D12_ROOT_PARAMETER_TYPE_CBV = 2,
1180     D3D12_ROOT_PARAMETER_TYPE_SRV = 3,
1181     D3D12_ROOT_PARAMETER_TYPE_UAV = 4,
1182 } D3D12_ROOT_PARAMETER_TYPE;
1183
1184 typedef enum D3D12_SHADER_VISIBILITY
1185 {
1186     D3D12_SHADER_VISIBILITY_ALL = 0,
1187     D3D12_SHADER_VISIBILITY_VERTEX = 1,
1188     D3D12_SHADER_VISIBILITY_HULL = 2,
1189     D3D12_SHADER_VISIBILITY_DOMAIN = 3,
1190     D3D12_SHADER_VISIBILITY_GEOMETRY = 4,
1191     D3D12_SHADER_VISIBILITY_PIXEL = 5,
1192     D3D12_SHADER_VISIBILITY_AMPLIFICATION = 6,
1193     D3D12_SHADER_VISIBILITY_MESH = 7,
1194 } D3D12_SHADER_VISIBILITY;
1195
1196 typedef struct D3D12_ROOT_PARAMETER
1197 {
1198     D3D12_ROOT_PARAMETER_TYPE ParameterType;
1199     union
1200     {
1201         D3D12_ROOT_DESCRIPTOR_TABLE DescriptorTable;
1202         D3D12_ROOT_CONSTANTS Constants;
1203         D3D12_ROOT_DESCRIPTOR Descriptor;
1204     };
1205     D3D12_SHADER_VISIBILITY ShaderVisibility;
1206 } D3D12_ROOT_PARAMETER;
1207
1208 typedef struct D3D12_ROOT_PARAMETER1
1209 {
1210     D3D12_ROOT_PARAMETER_TYPE ParameterType;
1211     union
1212     {
1213         D3D12_ROOT_DESCRIPTOR_TABLE1 DescriptorTable;
1214         D3D12_ROOT_CONSTANTS Constants;
1215         D3D12_ROOT_DESCRIPTOR1 Descriptor;
1216     };
1217     D3D12_SHADER_VISIBILITY ShaderVisibility;
1218 } D3D12_ROOT_PARAMETER1;
1219
1220 typedef enum D3D12_STATIC_BORDER_COLOR
1221 {
1222     D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK = 0,
1223     D3D12_STATIC_BORDER_COLOR_OPAQUE_BLACK = 1,
1224     D3D12_STATIC_BORDER_COLOR_OPAQUE_WHITE = 2,
1225 } D3D12_STATIC_BORDER_COLOR;
1226
1227 typedef enum D3D12_FILTER
1228 {
1229     D3D12_FILTER_MIN_MAG_MIP_POINT = 0x00,
1230     D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01,
1231     D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04,
1232     D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05,
1233     D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10,
1234     D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
1235     D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14,
1236     D3D12_FILTER_MIN_MAG_MIP_LINEAR = 0x15,
1237     D3D12_FILTER_ANISOTROPIC = 0x55,
1238     D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80,
1239     D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81,
1240     D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84,
1241     D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85,
1242     D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90,
1243     D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91,
1244     D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94,
1245     D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95,
1246     D3D12_FILTER_COMPARISON_ANISOTROPIC = 0xd5,
1247     D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100,
1248     D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101,
1249     D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104,
1250     D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105,
1251     D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110,
1252     D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111,
1253     D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114,
1254     D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115,
1255     D3D12_FILTER_MINIMUM_ANISOTROPIC = 0x155,
1256     D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180,
1257     D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181,
1258     D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184,
1259     D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185,
1260     D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190,
1261     D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191,
1262     D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194,
1263     D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195,
1264     D3D12_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5,
1265 } D3D12_FILTER;
1266
1267 typedef enum D3D12_FILTER_TYPE
1268 {
1269     D3D12_FILTER_TYPE_POINT = 0,
1270     D3D12_FILTER_TYPE_LINEAR = 1,
1271 } D3D12_FILTER_TYPE;
1272
1273 const UINT D3D12_MIP_FILTER_SHIFT = 0;
1274 const UINT D3D12_MAG_FILTER_SHIFT = 2;
1275 const UINT D3D12_MIN_FILTER_SHIFT = 4;
1276 const UINT D3D12_FILTER_TYPE_MASK = 0x3;
1277
1278 const UINT D3D12_ANISOTROPIC_FILTERING_BIT = 0x40;
1279
1280 typedef enum D3D12_FILTER_REDUCTION_TYPE
1281 {
1282     D3D12_FILTER_REDUCTION_TYPE_STANDARD = 0,
1283     D3D12_FILTER_REDUCTION_TYPE_COMPARISON = 1,
1284     D3D12_FILTER_REDUCTION_TYPE_MINIMUM = 2,
1285     D3D12_FILTER_REDUCTION_TYPE_MAXIMUM = 3,
1286 } D3D12_FILTER_REDUCTION_TYPE;
1287
1288 const UINT D3D12_FILTER_REDUCTION_TYPE_MASK = 0x3;
1289 const UINT D3D12_FILTER_REDUCTION_TYPE_SHIFT = 7;
1290
1291 cpp_quote("#define D3D12_ENCODE_BASIC_FILTER(min, mag, mip, reduction) \\")
1292 cpp_quote("    ((D3D12_FILTER) ( \\")
1293 cpp_quote("    (((min) & D3D12_FILTER_TYPE_MASK) << D3D12_MIN_FILTER_SHIFT) \\")
1294 cpp_quote("    | (((mag) & D3D12_FILTER_TYPE_MASK) << D3D12_MAG_FILTER_SHIFT) \\")
1295 cpp_quote("    | (((mip) & D3D12_FILTER_TYPE_MASK) << D3D12_MIP_FILTER_SHIFT) \\")
1296 cpp_quote("    | (((reduction) & D3D12_FILTER_REDUCTION_TYPE_MASK) << D3D12_FILTER_REDUCTION_TYPE_SHIFT)))")
1297
1298 cpp_quote("#define D3D12_ENCODE_ANISOTROPIC_FILTER(reduction) \\")
1299 cpp_quote("    ((D3D12_FILTER) ( \\")
1300 cpp_quote("     D3D12_ANISOTROPIC_FILTERING_BIT \\")
1301 cpp_quote("     | D3D12_ENCODE_BASIC_FILTER(D3D12_FILTER_TYPE_LINEAR, \\")
1302 cpp_quote("                                 D3D12_FILTER_TYPE_LINEAR, \\")
1303 cpp_quote("                                 D3D12_FILTER_TYPE_LINEAR, \\")
1304 cpp_quote("                                 reduction)))")
1305
1306 cpp_quote("#define D3D12_DECODE_MAG_FILTER(filter) \\")
1307 cpp_quote("    ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MAG_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))")
1308
1309 cpp_quote("#define D3D12_DECODE_MIN_FILTER(filter) \\")
1310 cpp_quote("    ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MIN_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))")
1311
1312 cpp_quote("#define D3D12_DECODE_MIP_FILTER(filter) \\")
1313 cpp_quote("    ((D3D12_FILTER_TYPE)(((filter) >> D3D12_MIP_FILTER_SHIFT) & D3D12_FILTER_TYPE_MASK))")
1314
1315 cpp_quote("#define D3D12_DECODE_IS_ANISOTROPIC_FILTER(filter)  \\")
1316 cpp_quote("    (((filter) & D3D12_ANISOTROPIC_FILTERING_BIT) \\")
1317 cpp_quote("    && (D3D12_DECODE_MIN_FILTER(filter) == D3D12_FILTER_TYPE_LINEAR) \\")
1318 cpp_quote("    && (D3D12_DECODE_MAG_FILTER(filter) == D3D12_FILTER_TYPE_LINEAR) \\")
1319 cpp_quote("    && (D3D12_DECODE_MIP_FILTER(filter) == D3D12_FILTER_TYPE_LINEAR))")
1320
1321 cpp_quote("#define D3D12_DECODE_FILTER_REDUCTION(filter) \\")
1322 cpp_quote("    ((D3D12_FILTER_REDUCTION_TYPE)(((filter) >> D3D12_FILTER_REDUCTION_TYPE_SHIFT) \\")
1323 cpp_quote("    & D3D12_FILTER_REDUCTION_TYPE_MASK))")
1324
1325 cpp_quote("#define D3D12_DECODE_IS_COMPARISON_FILTER(filter) \\")
1326 cpp_quote("    (D3D12_DECODE_FILTER_REDUCTION(filter) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON)")
1327
1328 typedef enum D3D12_TEXTURE_ADDRESS_MODE
1329 {
1330     D3D12_TEXTURE_ADDRESS_MODE_WRAP = 1,
1331     D3D12_TEXTURE_ADDRESS_MODE_MIRROR = 2,
1332     D3D12_TEXTURE_ADDRESS_MODE_CLAMP = 3,
1333     D3D12_TEXTURE_ADDRESS_MODE_BORDER = 4,
1334     D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5,
1335 } D3D12_TEXTURE_ADDRESS_MODE;
1336
1337 typedef enum D3D12_COMPARISON_FUNC
1338 {
1339     D3D12_COMPARISON_FUNC_NEVER = 1,
1340     D3D12_COMPARISON_FUNC_LESS = 2,
1341     D3D12_COMPARISON_FUNC_EQUAL = 3,
1342     D3D12_COMPARISON_FUNC_LESS_EQUAL = 4,
1343     D3D12_COMPARISON_FUNC_GREATER = 5,
1344     D3D12_COMPARISON_FUNC_NOT_EQUAL = 6,
1345     D3D12_COMPARISON_FUNC_GREATER_EQUAL = 7,
1346     D3D12_COMPARISON_FUNC_ALWAYS = 8,
1347 } D3D12_COMPARISON_FUNC;
1348
1349 typedef struct D3D12_STATIC_SAMPLER_DESC
1350 {
1351     D3D12_FILTER Filter;
1352     D3D12_TEXTURE_ADDRESS_MODE AddressU;
1353     D3D12_TEXTURE_ADDRESS_MODE AddressV;
1354     D3D12_TEXTURE_ADDRESS_MODE AddressW;
1355     FLOAT MipLODBias;
1356     UINT MaxAnisotropy;
1357     D3D12_COMPARISON_FUNC ComparisonFunc;
1358     D3D12_STATIC_BORDER_COLOR BorderColor;
1359     FLOAT MinLOD;
1360     FLOAT MaxLOD;
1361     UINT ShaderRegister;
1362     UINT RegisterSpace;
1363     D3D12_SHADER_VISIBILITY ShaderVisibility;
1364 } D3D12_STATIC_SAMPLER_DESC;
1365
1366 typedef enum D3D12_ROOT_SIGNATURE_FLAGS
1367 {
1368     D3D12_ROOT_SIGNATURE_FLAG_NONE = 0x00,
1369     D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT = 0x01,
1370     D3D12_ROOT_SIGNATURE_FLAG_DENY_VERTEX_SHADER_ROOT_ACCESS = 0x02,
1371     D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS = 0x04,
1372     D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS = 0x08,
1373     D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS = 0x10,
1374     D3D12_ROOT_SIGNATURE_FLAG_DENY_PIXEL_SHADER_ROOT_ACCESS = 0x20,
1375     D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT = 0x40,
1376     D3D12_ROOT_SIGNATURE_FLAG_LOCAL_ROOT_SIGNATURE = 0x80,
1377     D3D12_ROOT_SIGNATURE_FLAG_DENY_AMPLIFICATION_SHADER_ROOT_ACCESS = 0x100,
1378     D3D12_ROOT_SIGNATURE_FLAG_DENY_MESH_SHADER_ROOT_ACCESS = 0x200,
1379     D3D12_ROOT_SIGNATURE_FLAG_CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED = 0x400,
1380     D3D12_ROOT_SIGNATURE_FLAG_SAMPLER_HEAP_DIRECTLY_INDEXED = 0x800,
1381 } D3D12_ROOT_SIGNATURE_FLAGS;
1382 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_ROOT_SIGNATURE_FLAGS);")
1383
1384 typedef struct D3D12_ROOT_SIGNATURE_DESC
1385 {
1386     UINT NumParameters;
1387     const D3D12_ROOT_PARAMETER *pParameters;
1388     UINT NumStaticSamplers;
1389     const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers;
1390     D3D12_ROOT_SIGNATURE_FLAGS Flags;
1391 } D3D12_ROOT_SIGNATURE_DESC;
1392
1393 typedef struct D3D12_ROOT_SIGNATURE_DESC1
1394 {
1395     UINT NumParameters;
1396     const D3D12_ROOT_PARAMETER1 *pParameters;
1397     UINT NumStaticSamplers;
1398     const D3D12_STATIC_SAMPLER_DESC *pStaticSamplers;
1399     D3D12_ROOT_SIGNATURE_FLAGS Flags;
1400 } D3D12_ROOT_SIGNATURE_DESC1;
1401
1402 typedef enum D3D_ROOT_SIGNATURE_VERSION
1403 {
1404     D3D_ROOT_SIGNATURE_VERSION_1 = 0x1,
1405     D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1,
1406     D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2,
1407 } D3D_ROOT_SIGNATURE_VERSION;
1408
1409 typedef struct D3D12_VERSIONED_ROOT_SIGNATURE_DESC
1410 {
1411     D3D_ROOT_SIGNATURE_VERSION Version;
1412     union
1413     {
1414         D3D12_ROOT_SIGNATURE_DESC Desc_1_0;
1415         D3D12_ROOT_SIGNATURE_DESC1 Desc_1_1;
1416     };
1417 } D3D12_VERSIONED_ROOT_SIGNATURE_DESC;
1418
1419 typedef enum D3D12_DESCRIPTOR_HEAP_TYPE
1420 {
1421     D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
1422     D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
1423     D3D12_DESCRIPTOR_HEAP_TYPE_RTV,
1424     D3D12_DESCRIPTOR_HEAP_TYPE_DSV,
1425     D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES,
1426 } D3D12_DESCRIPTOR_HEAP_TYPE;
1427
1428 typedef enum D3D12_DESCRIPTOR_HEAP_FLAGS
1429 {
1430     D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0x0,
1431     D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1,
1432 } D3D12_DESCRIPTOR_HEAP_FLAGS;
1433 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DESCRIPTOR_HEAP_FLAGS);")
1434
1435 typedef struct D3D12_DESCRIPTOR_HEAP_DESC
1436 {
1437     D3D12_DESCRIPTOR_HEAP_TYPE Type;
1438     UINT NumDescriptors;
1439     D3D12_DESCRIPTOR_HEAP_FLAGS Flags;
1440     UINT NodeMask;
1441 } D3D12_DESCRIPTOR_HEAP_DESC;
1442
1443 typedef UINT64 D3D12_GPU_VIRTUAL_ADDRESS;
1444
1445 typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC
1446 {
1447     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
1448     UINT SizeInBytes;
1449 } D3D12_CONSTANT_BUFFER_VIEW_DESC;
1450
1451 typedef enum D3D12_SRV_DIMENSION
1452 {
1453     D3D12_SRV_DIMENSION_UNKNOWN = 0,
1454     D3D12_SRV_DIMENSION_BUFFER = 1,
1455     D3D12_SRV_DIMENSION_TEXTURE1D = 2,
1456     D3D12_SRV_DIMENSION_TEXTURE1DARRAY = 3,
1457     D3D12_SRV_DIMENSION_TEXTURE2D = 4,
1458     D3D12_SRV_DIMENSION_TEXTURE2DARRAY = 5,
1459     D3D12_SRV_DIMENSION_TEXTURE2DMS = 6,
1460     D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY = 7,
1461     D3D12_SRV_DIMENSION_TEXTURE3D = 8,
1462     D3D12_SRV_DIMENSION_TEXTURECUBE = 9,
1463     D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = 10,
1464     D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE = 11,
1465 } D3D12_SRV_DIMENSION;
1466
1467 typedef enum D3D12_BUFFER_SRV_FLAGS
1468 {
1469     D3D12_BUFFER_SRV_FLAG_NONE = 0x0,
1470     D3D12_BUFFER_SRV_FLAG_RAW = 0x1,
1471 } D3D12_BUFFER_SRV_FLAGS;
1472 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BUFFER_SRV_FLAGS);")
1473
1474 typedef enum D3D12_SHADER_COMPONENT_MAPPING
1475 {
1476     D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 = 0,
1477     D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 = 1,
1478     D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 = 2,
1479     D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 = 3,
1480     D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 = 4,
1481     D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 = 5,
1482 } D3D12_SHADER_COMPONENT_MAPPING;
1483
1484 cpp_quote("#define D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(x, y, z, w) \\")
1485 cpp_quote("        (((x) & D3D12_SHADER_COMPONENT_MAPPING_MASK) \\")
1486 cpp_quote("        | (((y) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << D3D12_SHADER_COMPONENT_MAPPING_SHIFT) \\")
1487 cpp_quote("        | (((z) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 2)) \\")
1488 cpp_quote("        | (((w) & D3D12_SHADER_COMPONENT_MAPPING_MASK) << (D3D12_SHADER_COMPONENT_MAPPING_SHIFT * 3)) \\")
1489 cpp_quote("        | D3D12_SHADER_COMPONENT_MAPPING_ALWAYS_SET_BIT_AVOIDING_ZEROMEM_MISTAKES)")
1490 cpp_quote("#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0, 1, 2, 3)")
1491
1492 cpp_quote("#define D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(i, mapping) \\")
1493 cpp_quote("        ((D3D12_SHADER_COMPONENT_MAPPING)(mapping >> (i * D3D12_SHADER_COMPONENT_MAPPING_SHIFT) \\")
1494 cpp_quote("        & D3D12_SHADER_COMPONENT_MAPPING_MASK))")
1495
1496 typedef struct D3D12_BUFFER_SRV
1497 {
1498     UINT64 FirstElement;
1499     UINT NumElements;
1500     UINT StructureByteStride;
1501     D3D12_BUFFER_SRV_FLAGS Flags;
1502 } D3D12_BUFFER_SRV;
1503
1504 typedef struct D3D12_TEX1D_SRV
1505 {
1506     UINT MostDetailedMip;
1507     UINT MipLevels;
1508     FLOAT ResourceMinLODClamp;
1509 } D3D12_TEX1D_SRV;
1510
1511 typedef struct D3D12_TEX1D_ARRAY_SRV
1512 {
1513     UINT MostDetailedMip;
1514     UINT MipLevels;
1515     UINT FirstArraySlice;
1516     UINT ArraySize;
1517     FLOAT ResourceMinLODClamp;
1518 } D3D12_TEX1D_ARRAY_SRV;
1519
1520 typedef struct D3D12_TEX2D_SRV
1521 {
1522     UINT MostDetailedMip;
1523     UINT MipLevels;
1524     UINT PlaneSlice;
1525     FLOAT ResourceMinLODClamp;
1526 } D3D12_TEX2D_SRV;
1527
1528 typedef struct D3D12_TEX2D_ARRAY_SRV
1529 {
1530     UINT MostDetailedMip;
1531     UINT MipLevels;
1532     UINT FirstArraySlice;
1533     UINT ArraySize;
1534     UINT PlaneSlice;
1535     FLOAT ResourceMinLODClamp;
1536 } D3D12_TEX2D_ARRAY_SRV;
1537
1538 typedef struct D3D12_TEX2DMS_SRV
1539 {
1540     UINT UnusedField_NothingToDefine;
1541 } D3D12_TEX2DMS_SRV;
1542
1543 typedef struct D3D12_TEX2DMS_ARRAY_SRV
1544 {
1545     UINT FirstArraySlice;
1546     UINT ArraySize;
1547 } D3D12_TEX2DMS_ARRAY_SRV;
1548
1549 typedef struct D3D12_TEX3D_SRV
1550 {
1551     UINT MostDetailedMip;
1552     UINT MipLevels;
1553     FLOAT ResourceMinLODClamp;
1554 } D3D12_TEX3D_SRV;
1555
1556 typedef struct D3D12_TEXCUBE_SRV
1557 {
1558     UINT MostDetailedMip;
1559     UINT MipLevels;
1560     FLOAT ResourceMinLODClamp;
1561 } D3D12_TEXCUBE_SRV;
1562
1563 typedef struct D3D12_TEXCUBE_ARRAY_SRV
1564 {
1565     UINT MostDetailedMip;
1566     UINT MipLevels;
1567     UINT First2DArrayFace;
1568     UINT NumCubes;
1569     FLOAT ResourceMinLODClamp;
1570 } D3D12_TEXCUBE_ARRAY_SRV;
1571
1572 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV
1573 {
1574     D3D12_GPU_VIRTUAL_ADDRESS Location;
1575 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV;
1576
1577 typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC
1578 {
1579     DXGI_FORMAT Format;
1580     D3D12_SRV_DIMENSION ViewDimension;
1581     UINT Shader4ComponentMapping;
1582     union
1583     {
1584         D3D12_BUFFER_SRV Buffer;
1585         D3D12_TEX1D_SRV Texture1D;
1586         D3D12_TEX1D_ARRAY_SRV Texture1DArray;
1587         D3D12_TEX2D_SRV Texture2D;
1588         D3D12_TEX2D_ARRAY_SRV Texture2DArray;
1589         D3D12_TEX2DMS_SRV Texture2DMS;
1590         D3D12_TEX2DMS_ARRAY_SRV Texture2DMSArray;
1591         D3D12_TEX3D_SRV Texture3D;
1592         D3D12_TEXCUBE_SRV TextureCube;
1593         D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray;
1594         D3D12_RAYTRACING_ACCELERATION_STRUCTURE_SRV RaytracingAccelerationStructure;
1595     };
1596 } D3D12_SHADER_RESOURCE_VIEW_DESC;
1597
1598 typedef enum D3D12_UAV_DIMENSION
1599 {
1600     D3D12_UAV_DIMENSION_UNKNOWN = 0,
1601     D3D12_UAV_DIMENSION_BUFFER = 1,
1602     D3D12_UAV_DIMENSION_TEXTURE1D = 2,
1603     D3D12_UAV_DIMENSION_TEXTURE1DARRAY = 3,
1604     D3D12_UAV_DIMENSION_TEXTURE2D = 4,
1605     D3D12_UAV_DIMENSION_TEXTURE2DARRAY = 5,
1606     D3D12_UAV_DIMENSION_TEXTURE3D = 8,
1607 } D3D12_UAV_DIMENSION;
1608
1609 typedef enum D3D12_BUFFER_UAV_FLAGS
1610 {
1611     D3D12_BUFFER_UAV_FLAG_NONE = 0x0,
1612     D3D12_BUFFER_UAV_FLAG_RAW = 0x1,
1613 } D3D12_BUFFER_UAV_FLAGS;
1614 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BUFFER_UAV_FLAGS);")
1615
1616 typedef struct D3D12_BUFFER_UAV
1617 {
1618     UINT64 FirstElement;
1619     UINT NumElements;
1620     UINT StructureByteStride;
1621     UINT64 CounterOffsetInBytes;
1622     D3D12_BUFFER_UAV_FLAGS Flags;
1623 } D3D12_BUFFER_UAV;
1624
1625 typedef struct D3D12_TEX1D_UAV
1626 {
1627     UINT MipSlice;
1628 } D3D12_TEX1D_UAV;
1629
1630 typedef struct D3D12_TEX1D_ARRAY_UAV
1631 {
1632     UINT MipSlice;
1633     UINT FirstArraySlice;
1634     UINT ArraySize;
1635 } D3D12_TEX1D_ARRAY_UAV;
1636
1637 typedef struct D3D12_TEX2D_UAV
1638 {
1639     UINT MipSlice;
1640     UINT PlaneSlice;
1641 } D3D12_TEX2D_UAV;
1642
1643 typedef struct D3D12_TEX2D_ARRAY_UAV
1644 {
1645     UINT MipSlice;
1646     UINT FirstArraySlice;
1647     UINT ArraySize;
1648     UINT PlaneSlice;
1649 } D3D12_TEX2D_ARRAY_UAV;
1650
1651 typedef struct D3D12_TEX3D_UAV
1652 {
1653     UINT MipSlice;
1654     UINT FirstWSlice;
1655     UINT WSize;
1656 } D3D12_TEX3D_UAV;
1657
1658 typedef struct D3D12_UNORDERED_ACCESS_VIEW_DESC
1659 {
1660     DXGI_FORMAT Format;
1661     D3D12_UAV_DIMENSION ViewDimension;
1662     union
1663     {
1664         D3D12_BUFFER_UAV Buffer;
1665         D3D12_TEX1D_UAV Texture1D;
1666         D3D12_TEX1D_ARRAY_UAV Texture1DArray;
1667         D3D12_TEX2D_UAV Texture2D;
1668         D3D12_TEX2D_ARRAY_UAV Texture2DArray;
1669         D3D12_TEX3D_UAV Texture3D;
1670     };
1671 } D3D12_UNORDERED_ACCESS_VIEW_DESC;
1672
1673 typedef enum D3D12_RTV_DIMENSION
1674 {
1675     D3D12_RTV_DIMENSION_UNKNOWN = 0,
1676     D3D12_RTV_DIMENSION_BUFFER = 1,
1677     D3D12_RTV_DIMENSION_TEXTURE1D = 2,
1678     D3D12_RTV_DIMENSION_TEXTURE1DARRAY = 3,
1679     D3D12_RTV_DIMENSION_TEXTURE2D = 4,
1680     D3D12_RTV_DIMENSION_TEXTURE2DARRAY = 5,
1681     D3D12_RTV_DIMENSION_TEXTURE2DMS = 6,
1682     D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY = 7,
1683     D3D12_RTV_DIMENSION_TEXTURE3D = 8,
1684 } D3D12_RTV_DIMENSION;
1685
1686 typedef struct D3D12_BUFFER_RTV
1687 {
1688     UINT64 FirstElement;
1689     UINT NumElements;
1690 } D3D12_BUFFER_RTV;
1691
1692 typedef struct D3D12_TEX1D_RTV
1693 {
1694     UINT MipSlice;
1695 } D3D12_TEX1D_RTV;
1696
1697 typedef struct D3D12_TEX1D_ARRAY_RTV
1698 {
1699     UINT MipSlice;
1700     UINT FirstArraySlice;
1701     UINT ArraySize;
1702 } D3D12_TEX1D_ARRAY_RTV;
1703
1704 typedef struct D3D12_TEX2D_RTV
1705 {
1706     UINT MipSlice;
1707     UINT PlaneSlice;
1708 } D3D12_TEX2D_RTV;
1709
1710 typedef struct D3D12_TEX2D_ARRAY_RTV
1711 {
1712     UINT MipSlice;
1713     UINT FirstArraySlice;
1714     UINT ArraySize;
1715     UINT PlaneSlice;
1716 } D3D12_TEX2D_ARRAY_RTV;
1717
1718 typedef struct D3D12_TEX2DMS_RTV
1719 {
1720     UINT UnusedField_NothingToDefine;
1721 } D3D12_TEX2DMS_RTV;
1722
1723 typedef struct D3D12_TEX2DMS_ARRAY_RTV
1724 {
1725     UINT FirstArraySlice;
1726     UINT ArraySize;
1727 } D3D12_TEX2DMS_ARRAY_RTV;
1728
1729 typedef struct D3D12_TEX3D_RTV
1730 {
1731     UINT MipSlice;
1732     UINT FirstWSlice;
1733     UINT WSize;
1734 } D3D12_TEX3D_RTV;
1735
1736 typedef struct D3D12_RENDER_TARGET_VIEW_DESC
1737 {
1738     DXGI_FORMAT Format;
1739     D3D12_RTV_DIMENSION ViewDimension;
1740     union
1741     {
1742         D3D12_BUFFER_RTV Buffer;
1743         D3D12_TEX1D_RTV Texture1D;
1744         D3D12_TEX1D_ARRAY_RTV Texture1DArray;
1745         D3D12_TEX2D_RTV Texture2D;
1746         D3D12_TEX2D_ARRAY_RTV Texture2DArray;
1747         D3D12_TEX2DMS_RTV Texture2DMS;
1748         D3D12_TEX2DMS_ARRAY_RTV Texture2DMSArray;
1749         D3D12_TEX3D_RTV Texture3D;
1750     };
1751 } D3D12_RENDER_TARGET_VIEW_DESC;
1752
1753 typedef enum D3D12_DSV_DIMENSION
1754 {
1755     D3D12_DSV_DIMENSION_UNKNOWN = 0,
1756     D3D12_DSV_DIMENSION_TEXTURE1D = 1,
1757     D3D12_DSV_DIMENSION_TEXTURE1DARRAY = 2,
1758     D3D12_DSV_DIMENSION_TEXTURE2D = 3,
1759     D3D12_DSV_DIMENSION_TEXTURE2DARRAY = 4,
1760     D3D12_DSV_DIMENSION_TEXTURE2DMS = 5,
1761     D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY = 6,
1762 } D3D12_DSV_DIMENSION;
1763
1764 typedef enum D3D12_DSV_FLAGS
1765 {
1766     D3D12_DSV_FLAG_NONE = 0x0,
1767     D3D12_DSV_FLAG_READ_ONLY_DEPTH = 0x1,
1768     D3D12_DSV_FLAG_READ_ONLY_STENCIL = 0x2,
1769 } D3D12_DSV_FLAGS;
1770 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DSV_FLAGS);")
1771
1772 typedef struct D3D12_TEX1D_DSV
1773 {
1774     UINT MipSlice;
1775 } D3D12_TEX1D_DSV;
1776
1777 typedef struct D3D12_TEX1D_ARRAY_DSV
1778 {
1779     UINT MipSlice;
1780     UINT FirstArraySlice;
1781     UINT ArraySize;
1782 } D3D12_TEX1D_ARRAY_DSV;
1783
1784 typedef struct D3D12_TEX2D_DSV
1785 {
1786     UINT MipSlice;
1787 } D3D12_TEX2D_DSV;
1788
1789 typedef struct D3D12_TEX2D_ARRAY_DSV
1790 {
1791     UINT MipSlice;
1792     UINT FirstArraySlice;
1793     UINT ArraySize;
1794 } D3D12_TEX2D_ARRAY_DSV;
1795
1796 typedef struct D3D12_TEX2DMS_DSV
1797 {
1798     UINT UnusedField_NothingToDefine;
1799 } D3D12_TEX2DMS_DSV;
1800
1801 typedef struct D3D12_TEX2DMS_ARRAY_DSV
1802 {
1803     UINT FirstArraySlice;
1804     UINT ArraySize;
1805 } D3D12_TEX2DMS_ARRAY_DSV;
1806
1807 typedef struct D3D12_DEPTH_STENCIL_VIEW_DESC
1808 {
1809     DXGI_FORMAT Format;
1810     D3D12_DSV_DIMENSION ViewDimension;
1811     D3D12_DSV_FLAGS Flags;
1812     union
1813     {
1814         D3D12_TEX1D_DSV Texture1D;
1815         D3D12_TEX1D_ARRAY_DSV Texture1DArray;
1816         D3D12_TEX2D_DSV Texture2D;
1817         D3D12_TEX2D_ARRAY_DSV Texture2DArray;
1818         D3D12_TEX2DMS_DSV Texture2DMS;
1819         D3D12_TEX2DMS_ARRAY_DSV Texture2DMSArray;
1820     };
1821 } D3D12_DEPTH_STENCIL_VIEW_DESC;
1822
1823 typedef struct D3D12_SAMPLER_DESC
1824 {
1825     D3D12_FILTER Filter;
1826     D3D12_TEXTURE_ADDRESS_MODE AddressU;
1827     D3D12_TEXTURE_ADDRESS_MODE AddressV;
1828     D3D12_TEXTURE_ADDRESS_MODE AddressW;
1829     FLOAT MipLODBias;
1830     UINT MaxAnisotropy;
1831     D3D12_COMPARISON_FUNC ComparisonFunc;
1832     FLOAT BorderColor[4];
1833     FLOAT MinLOD;
1834     FLOAT MaxLOD;
1835 } D3D12_SAMPLER_DESC;
1836
1837 typedef struct D3D12_CPU_DESCRIPTOR_HANDLE
1838 {
1839     SIZE_T ptr;
1840 } D3D12_CPU_DESCRIPTOR_HANDLE;
1841
1842 typedef struct D3D12_GPU_DESCRIPTOR_HANDLE
1843 {
1844     UINT64 ptr;
1845 } D3D12_GPU_DESCRIPTOR_HANDLE;
1846
1847 typedef enum D3D12_STENCIL_OP
1848 {
1849     D3D12_STENCIL_OP_KEEP = 1,
1850     D3D12_STENCIL_OP_ZERO = 2,
1851     D3D12_STENCIL_OP_REPLACE = 3,
1852     D3D12_STENCIL_OP_INCR_SAT = 4,
1853     D3D12_STENCIL_OP_DECR_SAT = 5,
1854     D3D12_STENCIL_OP_INVERT = 6,
1855     D3D12_STENCIL_OP_INCR = 7,
1856     D3D12_STENCIL_OP_DECR = 8,
1857 } D3D12_STENCIL_OP;
1858
1859 typedef struct D3D12_DEPTH_STENCILOP_DESC
1860 {
1861     D3D12_STENCIL_OP StencilFailOp;
1862     D3D12_STENCIL_OP StencilDepthFailOp;
1863     D3D12_STENCIL_OP StencilPassOp;
1864     D3D12_COMPARISON_FUNC StencilFunc;
1865 } D3D12_DEPTH_STENCILOP_DESC;
1866
1867 typedef enum D3D12_DEPTH_WRITE_MASK
1868 {
1869     D3D12_DEPTH_WRITE_MASK_ZERO = 0,
1870     D3D12_DEPTH_WRITE_MASK_ALL = 1,
1871 } D3D12_DEPTH_WRITE_MASK;
1872
1873 typedef struct D3D12_DEPTH_STENCIL_DESC
1874 {
1875     BOOL DepthEnable;
1876     D3D12_DEPTH_WRITE_MASK DepthWriteMask;
1877     D3D12_COMPARISON_FUNC DepthFunc;
1878     BOOL StencilEnable;
1879     UINT8 StencilReadMask;
1880     UINT8 StencilWriteMask;
1881     D3D12_DEPTH_STENCILOP_DESC FrontFace;
1882     D3D12_DEPTH_STENCILOP_DESC BackFace;
1883 } D3D12_DEPTH_STENCIL_DESC;
1884
1885 typedef struct D3D12_DEPTH_STENCIL_DESC1
1886 {
1887     BOOL DepthEnable;
1888     D3D12_DEPTH_WRITE_MASK DepthWriteMask;
1889     D3D12_COMPARISON_FUNC DepthFunc;
1890     BOOL StencilEnable;
1891     UINT8 StencilReadMask;
1892     UINT8 StencilWriteMask;
1893     D3D12_DEPTH_STENCILOP_DESC FrontFace;
1894     D3D12_DEPTH_STENCILOP_DESC BackFace;
1895     BOOL DepthBoundsTestEnable;
1896 } D3D12_DEPTH_STENCIL_DESC1;
1897
1898 typedef enum D3D12_BLEND
1899 {
1900     D3D12_BLEND_ZERO = 1,
1901     D3D12_BLEND_ONE = 2,
1902     D3D12_BLEND_SRC_COLOR = 3,
1903     D3D12_BLEND_INV_SRC_COLOR = 4,
1904     D3D12_BLEND_SRC_ALPHA = 5,
1905     D3D12_BLEND_INV_SRC_ALPHA = 6,
1906     D3D12_BLEND_DEST_ALPHA = 7,
1907     D3D12_BLEND_INV_DEST_ALPHA = 8,
1908     D3D12_BLEND_DEST_COLOR = 9,
1909     D3D12_BLEND_INV_DEST_COLOR = 10,
1910     D3D12_BLEND_SRC_ALPHA_SAT = 11,
1911     D3D12_BLEND_BLEND_FACTOR = 14,
1912     D3D12_BLEND_INV_BLEND_FACTOR = 15,
1913     D3D12_BLEND_SRC1_COLOR = 16,
1914     D3D12_BLEND_INV_SRC1_COLOR = 17,
1915     D3D12_BLEND_SRC1_ALPHA = 18,
1916     D3D12_BLEND_INV_SRC1_ALPHA = 19,
1917     D3D12_BLEND_ALPHA_FACTOR = 20,
1918     D3D12_BLEND_INV_ALPHA_FACTOR = 21,
1919 } D3D12_BLEND;
1920
1921 typedef enum D3D12_BLEND_OP
1922 {
1923     D3D12_BLEND_OP_ADD = 1,
1924     D3D12_BLEND_OP_SUBTRACT = 2,
1925     D3D12_BLEND_OP_REV_SUBTRACT = 3,
1926     D3D12_BLEND_OP_MIN = 4,
1927     D3D12_BLEND_OP_MAX = 5,
1928 } D3D12_BLEND_OP;
1929
1930 typedef enum D3D12_LOGIC_OP
1931 {
1932     D3D12_LOGIC_OP_CLEAR = 0x0,
1933     D3D12_LOGIC_OP_SET = 0x1,
1934     D3D12_LOGIC_OP_COPY = 0x2,
1935     D3D12_LOGIC_OP_COPY_INVERTED = 0x3,
1936     D3D12_LOGIC_OP_NOOP = 0x4,
1937     D3D12_LOGIC_OP_INVERT = 0x5,
1938     D3D12_LOGIC_OP_AND = 0x6,
1939     D3D12_LOGIC_OP_NAND = 0x7,
1940     D3D12_LOGIC_OP_OR = 0x8,
1941     D3D12_LOGIC_OP_NOR = 0x9,
1942     D3D12_LOGIC_OP_XOR = 0xa,
1943     D3D12_LOGIC_OP_EQUIV = 0xb,
1944     D3D12_LOGIC_OP_AND_REVERSE = 0xc,
1945     D3D12_LOGIC_OP_AND_INVERTED = 0xd,
1946     D3D12_LOGIC_OP_OR_REVERSE = 0xe,
1947     D3D12_LOGIC_OP_OR_INVERTED = 0xf,
1948 } D3D12_LOGIC_OP;
1949
1950 typedef enum D3D12_COLOR_WRITE_ENABLE
1951 {
1952     D3D12_COLOR_WRITE_ENABLE_RED = 0x1,
1953     D3D12_COLOR_WRITE_ENABLE_GREEN = 0x2,
1954     D3D12_COLOR_WRITE_ENABLE_BLUE = 0x4,
1955     D3D12_COLOR_WRITE_ENABLE_ALPHA = 0x8,
1956     D3D12_COLOR_WRITE_ENABLE_ALL = (D3D12_COLOR_WRITE_ENABLE_RED
1957             | D3D12_COLOR_WRITE_ENABLE_GREEN | D3D12_COLOR_WRITE_ENABLE_BLUE
1958             | D3D12_COLOR_WRITE_ENABLE_ALPHA),
1959 } D3D12_COLOR_WRITE_ENABLE;
1960
1961 typedef struct D3D12_RENDER_TARGET_BLEND_DESC
1962 {
1963     BOOL BlendEnable;
1964     BOOL LogicOpEnable;
1965     D3D12_BLEND SrcBlend;
1966     D3D12_BLEND DestBlend;
1967     D3D12_BLEND_OP BlendOp;
1968     D3D12_BLEND SrcBlendAlpha;
1969     D3D12_BLEND DestBlendAlpha;
1970     D3D12_BLEND_OP BlendOpAlpha;
1971     D3D12_LOGIC_OP LogicOp;
1972     UINT8 RenderTargetWriteMask;
1973 } D3D12_RENDER_TARGET_BLEND_DESC;
1974
1975 typedef struct D3D12_BLEND_DESC
1976 {
1977     BOOL AlphaToCoverageEnable;
1978     BOOL IndependentBlendEnable;
1979     D3D12_RENDER_TARGET_BLEND_DESC RenderTarget[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT];
1980 } D3D12_BLEND_DESC;
1981
1982 typedef enum D3D12_FILL_MODE
1983 {
1984     D3D12_FILL_MODE_WIREFRAME = 2,
1985     D3D12_FILL_MODE_SOLID = 3,
1986 } D3D12_FILL_MODE;
1987
1988 typedef enum D3D12_CULL_MODE
1989 {
1990     D3D12_CULL_MODE_NONE = 1,
1991     D3D12_CULL_MODE_FRONT = 2,
1992     D3D12_CULL_MODE_BACK = 3,
1993 } D3D12_CULL_MODE;
1994
1995 typedef enum D3D12_CONSERVATIVE_RASTERIZATION_MODE
1996 {
1997     D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF = 0,
1998     D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON = 1,
1999 } D3D12_CONSERVATIVE_RASTERIZATION_MODE;
2000
2001 typedef struct D3D12_RASTERIZER_DESC
2002 {
2003     D3D12_FILL_MODE FillMode;
2004     D3D12_CULL_MODE CullMode;
2005     BOOL FrontCounterClockwise;
2006     INT DepthBias;
2007     FLOAT DepthBiasClamp;
2008     FLOAT SlopeScaledDepthBias;
2009     BOOL DepthClipEnable;
2010     BOOL MultisampleEnable;
2011     BOOL AntialiasedLineEnable;
2012     UINT ForcedSampleCount;
2013     D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster;
2014 } D3D12_RASTERIZER_DESC;
2015
2016 typedef struct D3D12_SO_DECLARATION_ENTRY
2017 {
2018     UINT Stream;
2019     const char *SemanticName;
2020     UINT SemanticIndex;
2021     BYTE StartComponent;
2022     BYTE ComponentCount;
2023     BYTE OutputSlot;
2024 } D3D12_SO_DECLARATION_ENTRY;
2025
2026 typedef struct D3D12_STREAM_OUTPUT_DESC
2027 {
2028     const D3D12_SO_DECLARATION_ENTRY *pSODeclaration;
2029     UINT NumEntries;
2030     const UINT *pBufferStrides;
2031     UINT NumStrides;
2032     UINT RasterizedStream;
2033 } D3D12_STREAM_OUTPUT_DESC;
2034
2035 typedef enum D3D12_INPUT_CLASSIFICATION
2036 {
2037     D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA = 0,
2038     D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA = 1,
2039 } D3D12_INPUT_CLASSIFICATION;
2040
2041 typedef struct D3D12_INPUT_ELEMENT_DESC
2042 {
2043     const char *SemanticName;
2044     UINT SemanticIndex;
2045     DXGI_FORMAT Format;
2046     UINT InputSlot;
2047     UINT AlignedByteOffset;
2048     D3D12_INPUT_CLASSIFICATION InputSlotClass;
2049     UINT InstanceDataStepRate;
2050 } D3D12_INPUT_ELEMENT_DESC;
2051
2052 typedef struct D3D12_INPUT_LAYOUT_DESC
2053 {
2054     const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs;
2055     UINT NumElements;
2056 } D3D12_INPUT_LAYOUT_DESC;
2057
2058 typedef enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE
2059 {
2060     D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED = 0,
2061     D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF = 1,
2062     D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = 2,
2063 } D3D12_INDEX_BUFFER_STRIP_CUT_VALUE;
2064
2065 typedef D3D_PRIMITIVE_TOPOLOGY D3D12_PRIMITIVE_TOPOLOGY;
2066
2067 typedef D3D_PRIMITIVE D3D12_PRIMITIVE;
2068
2069 typedef enum D3D12_PRIMITIVE_TOPOLOGY_TYPE
2070 {
2071     D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = 0,
2072     D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT = 1,
2073     D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE = 2,
2074     D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE = 3,
2075     D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH = 4,
2076 } D3D12_PRIMITIVE_TOPOLOGY_TYPE;
2077
2078 typedef struct D3D12_CACHED_PIPELINE_STATE
2079 {
2080     const void *pCachedBlob;
2081     SIZE_T CachedBlobSizeInBytes;
2082 } D3D12_CACHED_PIPELINE_STATE;
2083
2084 typedef enum D3D12_PIPELINE_STATE_FLAGS
2085 {
2086     D3D12_PIPELINE_STATE_FLAG_NONE = 0x0,
2087     D3D12_PIPELINE_STATE_FLAG_DEBUG = 0x1,
2088 } D3D12_PIPELINE_STATE_FLAGS;
2089 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PIPELINE_STATE_FLAGS);")
2090
2091 typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC
2092 {
2093     ID3D12RootSignature *pRootSignature;
2094     D3D12_SHADER_BYTECODE VS;
2095     D3D12_SHADER_BYTECODE PS;
2096     D3D12_SHADER_BYTECODE DS;
2097     D3D12_SHADER_BYTECODE HS;
2098     D3D12_SHADER_BYTECODE GS;
2099     D3D12_STREAM_OUTPUT_DESC StreamOutput;
2100     D3D12_BLEND_DESC BlendState;
2101     UINT SampleMask;
2102     D3D12_RASTERIZER_DESC RasterizerState;
2103     D3D12_DEPTH_STENCIL_DESC DepthStencilState;
2104     D3D12_INPUT_LAYOUT_DESC InputLayout;
2105     D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue;
2106     D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
2107     UINT NumRenderTargets;
2108     DXGI_FORMAT RTVFormats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT];
2109     DXGI_FORMAT DSVFormat;
2110     DXGI_SAMPLE_DESC SampleDesc;
2111     UINT NodeMask;
2112     D3D12_CACHED_PIPELINE_STATE CachedPSO;
2113     D3D12_PIPELINE_STATE_FLAGS Flags;
2114 } D3D12_GRAPHICS_PIPELINE_STATE_DESC;
2115
2116 typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC
2117 {
2118     ID3D12RootSignature *pRootSignature;
2119     D3D12_SHADER_BYTECODE CS;
2120     UINT NodeMask;
2121     D3D12_CACHED_PIPELINE_STATE CachedPSO;
2122     D3D12_PIPELINE_STATE_FLAGS Flags;
2123 } D3D12_COMPUTE_PIPELINE_STATE_DESC;
2124
2125 typedef struct D3D12_PIPELINE_STATE_STREAM_DESC
2126 {
2127     SIZE_T SizeInBytes;
2128     void *pPipelineStateSubobjectStream;
2129 } D3D12_PIPELINE_STATE_STREAM_DESC;
2130
2131 struct D3D12_RT_FORMAT_ARRAY
2132 {
2133     DXGI_FORMAT RTFormats[D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT];
2134     UINT NumRenderTargets;
2135 };
2136
2137 typedef enum D3D12_PIPELINE_STATE_SUBOBJECT_TYPE
2138 {
2139     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE = 0x0,
2140     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VS = 0x1,
2141     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PS = 0x2,
2142     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DS = 0x3,
2143     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_HS = 0x4,
2144     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_GS = 0x5,
2145     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CS = 0x6,
2146     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_STREAM_OUTPUT = 0x7,
2147     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_BLEND = 0x8,
2148     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_MASK = 0x9,
2149     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RASTERIZER = 0xa,
2150     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL = 0xb,
2151     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_INPUT_LAYOUT = 0xc,
2152     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_IB_STRIP_CUT_VALUE = 0xd,
2153     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_PRIMITIVE_TOPOLOGY = 0xe,
2154     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_RENDER_TARGET_FORMATS = 0xf,
2155     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL_FORMAT = 0x10,
2156     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_SAMPLE_DESC = 0x11,
2157     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x12,
2158     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_CACHED_PSO = 0x13,
2159     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_FLAGS = 0x14,
2160     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_DEPTH_STENCIL1 = 0x15,
2161     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_VIEW_INSTANCING = 0x16,
2162     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_AS = 0x18,
2163     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MS = 0x19,
2164     D3D12_PIPELINE_STATE_SUBOBJECT_TYPE_MAX_VALID = 0x1a,
2165 } D3D12_PIPELINE_STATE_SUBOBJECT_TYPE;
2166
2167 typedef struct D3D12_VIEW_INSTANCE_LOCATION
2168 {
2169     UINT ViewportArrayIndex;
2170     UINT RenderTargetArrayIndex;
2171 } D3D12_VIEW_INSTANCE_LOCATION;
2172
2173 typedef enum D3D12_VIEW_INSTANCING_FLAGS
2174 {
2175     D3D12_VIEW_INSTANCING_FLAG_NONE = 0x0,
2176     D3D12_VIEW_INSTANCING_FLAG_ENABLE_VIEW_INSTANCE_MASKING = 0x1,
2177 } D3D12_VIEW_INSTANCING_FLAGS;
2178 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIEW_INSTANCING_FLAGS);")
2179
2180 typedef struct D3D12_VIEW_INSTANCING_DESC
2181 {
2182     UINT ViewInstanceCount;
2183     const D3D12_VIEW_INSTANCE_LOCATION *pViewInstanceLocations;
2184     D3D12_VIEW_INSTANCING_FLAGS Flags;
2185 } D3D12_VIEW_INSTANCING_DESC;
2186
2187 typedef enum D3D12_COMMAND_LIST_TYPE
2188 {
2189     D3D12_COMMAND_LIST_TYPE_DIRECT = 0,
2190     D3D12_COMMAND_LIST_TYPE_BUNDLE = 1,
2191     D3D12_COMMAND_LIST_TYPE_COMPUTE = 2,
2192     D3D12_COMMAND_LIST_TYPE_COPY = 3,
2193     D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE = 4,
2194     D3D12_COMMAND_LIST_TYPE_VIDEO_PROCESS = 5,
2195     D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE = 6,
2196 } D3D12_COMMAND_LIST_TYPE;
2197
2198 typedef enum D3D12_COMMAND_QUEUE_PRIORITY
2199 {
2200     D3D12_COMMAND_QUEUE_PRIORITY_NORMAL = 0,
2201     D3D12_COMMAND_QUEUE_PRIORITY_HIGH = 100,
2202     D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME = 10000,
2203 } D3D12_COMMAND_QUEUE_PRIORITY;
2204
2205 typedef enum D3D12_COMMAND_QUEUE_FLAGS
2206 {
2207     D3D12_COMMAND_QUEUE_FLAG_NONE = 0x0,
2208     D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1,
2209 } D3D12_COMMAND_QUEUE_FLAGS;
2210 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_QUEUE_FLAGS);")
2211
2212 typedef struct D3D12_COMMAND_QUEUE_DESC
2213 {
2214     D3D12_COMMAND_LIST_TYPE Type;
2215     INT Priority;
2216     D3D12_COMMAND_QUEUE_FLAGS Flags;
2217     UINT NodeMask;
2218 } D3D12_COMMAND_QUEUE_DESC;
2219
2220 typedef struct D3D12_FEATURE_DATA_ARCHITECTURE
2221 {
2222     UINT NodeIndex;
2223     BOOL TileBasedRenderer;
2224     BOOL UMA;
2225     BOOL CacheCoherentUMA;
2226 } D3D12_FEATURE_DATA_ARCHITECTURE;
2227
2228 typedef struct D3D12_FEATURE_DATA_FORMAT_INFO
2229 {
2230     DXGI_FORMAT Format;
2231     UINT8 PlaneCount;
2232 } D3D12_FEATURE_DATA_FORMAT_INFO;
2233
2234 typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS
2235 {
2236     UINT NumFeatureLevels;
2237     const D3D_FEATURE_LEVEL *pFeatureLevelsRequested;
2238     D3D_FEATURE_LEVEL MaxSupportedFeatureLevel;
2239 } D3D12_FEATURE_DATA_FEATURE_LEVELS;
2240
2241 typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE
2242 {
2243     D3D_ROOT_SIGNATURE_VERSION HighestVersion;
2244 } D3D12_FEATURE_DATA_ROOT_SIGNATURE;
2245
2246 typedef struct D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT
2247 {
2248     UINT MaxGPUVirtualAddressBitsPerResource;
2249     UINT MaxGPUVirtualAddressBitsPerProcess;
2250 } D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT;
2251
2252 typedef enum D3D_SHADER_MODEL
2253 {
2254     D3D_SHADER_MODEL_5_1 = 0x51,
2255     D3D_SHADER_MODEL_6_0 = 0x60,
2256     D3D_SHADER_MODEL_6_1 = 0x61,
2257     D3D_SHADER_MODEL_6_2 = 0x62,
2258     D3D_SHADER_MODEL_6_3 = 0x63,
2259     D3D_SHADER_MODEL_6_4 = 0x64,
2260     D3D_SHADER_MODEL_6_5 = 0x65,
2261     D3D_SHADER_MODEL_6_6 = 0x66,
2262     D3D_SHADER_MODEL_6_7 = 0x67,
2263     D3D_HIGHEST_SHADER_MODEL = D3D_SHADER_MODEL_6_7,
2264 } D3D_SHADER_MODEL;
2265
2266 typedef struct D3D12_FEATURE_DATA_SHADER_MODEL
2267 {
2268     D3D_SHADER_MODEL HighestShaderModel;
2269 } D3D12_FEATURE_DATA_SHADER_MODEL;
2270
2271 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1
2272 {
2273     BOOL WaveOps;
2274     UINT WaveLaneCountMin;
2275     UINT WaveLaneCountMax;
2276     UINT TotalLaneCount;
2277     BOOL ExpandedComputeResourceStates;
2278     BOOL Int64ShaderOps;
2279 }  D3D12_FEATURE_DATA_D3D12_OPTIONS1;
2280
2281 typedef struct D3D12_FEATURE_DATA_ARCHITECTURE1
2282 {
2283     UINT NodeIndex;
2284     BOOL TileBasedRenderer;
2285     BOOL UMA;
2286     BOOL CacheCoherentUMA;
2287     BOOL IsolatedMMU;
2288 }  D3D12_FEATURE_DATA_ARCHITECTURE1;
2289
2290 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS2
2291 {
2292     BOOL DepthBoundsTestSupported;
2293     D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER ProgrammableSamplePositionsTier;
2294 }  D3D12_FEATURE_DATA_D3D12_OPTIONS2;
2295
2296 typedef struct D3D12_FEATURE_DATA_SHADER_CACHE
2297 {
2298     D3D12_SHADER_CACHE_SUPPORT_FLAGS SupportFlags;
2299 }  D3D12_FEATURE_DATA_SHADER_CACHE;
2300
2301 typedef struct D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY
2302 {
2303     D3D12_COMMAND_LIST_TYPE CommandListType;
2304     UINT Priority;
2305     BOOL PriorityForTypeIsSupported;
2306 }  D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY;
2307
2308 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS3
2309 {
2310     BOOL CopyQueueTimestampQueriesSupported;
2311     BOOL CastingFullyTypedFormatSupported;
2312     D3D12_COMMAND_LIST_SUPPORT_FLAGS WriteBufferImmediateSupportFlags;
2313     D3D12_VIEW_INSTANCING_TIER ViewInstancingTier;
2314     BOOL BarycentricsSupported;
2315 } D3D12_FEATURE_DATA_D3D12_OPTIONS3;
2316
2317 typedef struct D3D12_FEATURE_DATA_EXISTING_HEAPS
2318 {
2319     BOOL Supported;
2320 }  D3D12_FEATURE_DATA_EXISTING_HEAPS;
2321
2322 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS4
2323 {
2324     BOOL MSAA64KBAlignedTextureSupported;
2325     D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER SharedResourceCompatibilityTier;
2326     BOOL Native16BitShaderOpsSupported;
2327 }  D3D12_FEATURE_DATA_D3D12_OPTIONS4;
2328
2329 typedef struct D3D12_FEATURE_DATA_SERIALIZATION
2330 {
2331     UINT NodeIndex;
2332     D3D12_HEAP_SERIALIZATION_TIER HeapSerializationTier;
2333 }  D3D12_FEATURE_DATA_SERIALIZATION;
2334
2335 typedef struct D3D12_FEATURE_DATA_CROSS_NODE
2336 {
2337     D3D12_CROSS_NODE_SHARING_TIER SharingTier;
2338     BOOL AtomicShaderInstructions;
2339 }  D3D12_FEATURE_DATA_CROSS_NODE;
2340
2341 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS5
2342 {
2343     BOOL SRVOnlyTiledResourceTier3;
2344     D3D12_RENDER_PASS_TIER RenderPassesTier;
2345     D3D12_RAYTRACING_TIER RaytracingTier;
2346 } D3D12_FEATURE_DATA_D3D12_OPTIONS5;
2347
2348 typedef enum D3D12_VARIABLE_SHADING_RATE_TIER
2349 {
2350     D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED = 0x0,
2351     D3D12_VARIABLE_SHADING_RATE_TIER_1 = 0x1,
2352     D3D12_VARIABLE_SHADING_RATE_TIER_2 = 0x2,
2353 } D3D12_VARIABLE_SHADING_RATE_TIER;
2354
2355 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS6
2356 {
2357     BOOL AdditionalShadingRatesSupported;
2358     BOOL PerPrimitiveShadingRateSupportedWithViewportIndexing;
2359     D3D12_VARIABLE_SHADING_RATE_TIER VariableShadingRateTier;
2360     UINT ShadingRateImageTileSize;
2361     BOOL BackgroundProcessingSupported;
2362 } D3D12_FEATURE_DATA_D3D12_OPTIONS6;
2363
2364 typedef enum D3D12_MESH_SHADER_TIER
2365 {
2366     D3D12_MESH_SHADER_TIER_NOT_SUPPORTED = 0x0,
2367     D3D12_MESH_SHADER_TIER_1 = 0xa,
2368 } D3D12_MESH_SHADER_TIER;
2369
2370 typedef enum D3D12_SAMPLER_FEEDBACK_TIER
2371 {
2372     D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED = 0x0,
2373     D3D12_SAMPLER_FEEDBACK_TIER_0_9 = 0x5a,
2374     D3D12_SAMPLER_FEEDBACK_TIER_1_0 = 0x64,
2375 } D3D12_SAMPLER_FEEDBACK_TIER;
2376
2377 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS7
2378 {
2379     D3D12_MESH_SHADER_TIER MeshShaderTier;
2380     D3D12_SAMPLER_FEEDBACK_TIER SamplerFeedbackTier;
2381 } D3D12_FEATURE_DATA_D3D12_OPTIONS7;
2382
2383 typedef struct D3D12_FEATURE_DATA_QUERY_META_COMMAND
2384 {
2385     GUID CommandId;
2386     UINT NodeMask;
2387     const void *pQueryInputData;
2388     SIZE_T QueryInputDataSizeInBytes;
2389     void *pQueryOutputData;
2390     SIZE_T QueryOutputDataSizeInBytes;
2391 } D3D12_FEATURE_DATA_QUERY_META_COMMAND;
2392
2393 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS8
2394 {
2395     BOOL UnalignedBlockTexturesSupported;
2396 } D3D12_FEATURE_DATA_D3D12_OPTIONS8;
2397
2398 typedef enum D3D12_WAVE_MMA_TIER
2399 {
2400     D3D12_WAVE_MMA_TIER_NOT_SUPPORTED = 0x0,
2401     D3D12_WAVE_MMA_TIER_1_0 = 0xa,
2402 } D3D12_WAVE_MMA_TIER;
2403
2404 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS9
2405 {
2406     BOOL MeshShaderPipelineStatsSupported;
2407     BOOL MeshShaderSupportsFullRangeRenderTargetArrayIndex;
2408     BOOL AtomicInt64OnTypedResourceSupported;
2409     BOOL AtomicInt64OnGroupSharedSupported;
2410     BOOL DerivativesInMeshAndAmplificationShadersSupported;
2411     D3D12_WAVE_MMA_TIER WaveMMATier;
2412 } D3D12_FEATURE_DATA_D3D12_OPTIONS9;
2413
2414 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS10
2415 {
2416     BOOL VariableRateShadingSumCombinerSupported;
2417     BOOL MeshShaderPerPrimitiveShadingRateSupported;
2418 } D3D12_FEATURE_DATA_D3D12_OPTIONS10;
2419
2420 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS11
2421 {
2422     BOOL AtomicInt64OnDescriptorHeapResourceSupported;
2423 } D3D12_FEATURE_DATA_D3D12_OPTIONS11;
2424
2425 typedef enum D3D12_TRI_STATE
2426 {
2427     D3D12_TRI_STATE_UNKNOWN = -0x1,
2428     D3D12_TRI_STATE_FALSE = 0x0,
2429     D3D12_TRI_STATE_TRUE = 0x1,
2430 } D3D12_TRI_STATE;
2431
2432 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS12
2433 {
2434     D3D12_TRI_STATE MSPrimitivesPipelineStatisticIncludesCulledPrimitives;
2435     BOOL EnhancedBarriersSupported;
2436     BOOL RelaxedFormatCastingSupported;
2437 } D3D12_FEATURE_DATA_D3D12_OPTIONS12;
2438
2439 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS13
2440 {
2441     BOOL UnrestrictedBufferTextureCopyPitchSupported;
2442     BOOL UnrestrictedVertexElementAlignmentSupported;
2443     BOOL InvertedViewportHeightFlipsYSupported;
2444     BOOL InvertedViewportDepthFlipsZSupported;
2445     BOOL TextureCopyBetweenDimensionsSupported;
2446     BOOL AlphaBlendFactorSupported;
2447 } D3D12_FEATURE_DATA_D3D12_OPTIONS13;
2448
2449 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS14
2450 {
2451     BOOL AdvancedTextureOpsSupported;
2452     BOOL WriteableMSAATexturesSupported;
2453     BOOL IndependentFrontAndBackStencilRefMaskSupported;
2454 } D3D12_FEATURE_DATA_D3D12_OPTIONS14;
2455
2456 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS15
2457 {
2458     BOOL TriangleFanSupported;
2459     BOOL DynamicIndexBufferStripCutSupported;
2460 } D3D12_FEATURE_DATA_D3D12_OPTIONS15;
2461
2462 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS16
2463 {
2464     BOOL DynamicDepthBiasSupported;
2465     BOOL GPUUploadHeapSupported;
2466 } D3D12_FEATURE_DATA_D3D12_OPTIONS16;
2467
2468 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS17
2469 {
2470     BOOL NonNormalizedCoordinateSamplersSupported;
2471     BOOL ManualWriteTrackingResourceSupported;
2472 } D3D12_FEATURE_DATA_D3D12_OPTIONS17;
2473
2474 typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS18
2475 {
2476     BOOL RenderPassesValid;
2477 } D3D12_FEATURE_DATA_D3D12_OPTIONS18;
2478
2479 typedef enum D3D12_FEATURE
2480 {
2481     D3D12_FEATURE_D3D12_OPTIONS = 0,
2482     D3D12_FEATURE_ARCHITECTURE = 1,
2483     D3D12_FEATURE_FEATURE_LEVELS = 2,
2484     D3D12_FEATURE_FORMAT_SUPPORT = 3,
2485     D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4,
2486     D3D12_FEATURE_FORMAT_INFO = 5,
2487     D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
2488     D3D12_FEATURE_SHADER_MODEL = 7,
2489     D3D12_FEATURE_D3D12_OPTIONS1 = 8,
2490     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = 10,
2491     D3D12_FEATURE_ROOT_SIGNATURE = 12,
2492     D3D12_FEATURE_ARCHITECTURE1 = 16,
2493     D3D12_FEATURE_D3D12_OPTIONS2 = 18,
2494     D3D12_FEATURE_SHADER_CACHE = 19,
2495     D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20,
2496     D3D12_FEATURE_D3D12_OPTIONS3 = 21,
2497     D3D12_FEATURE_EXISTING_HEAPS = 22,
2498     D3D12_FEATURE_D3D12_OPTIONS4 = 23,
2499     D3D12_FEATURE_SERIALIZATION = 24,
2500     D3D12_FEATURE_CROSS_NODE = 25,
2501     D3D12_FEATURE_D3D12_OPTIONS5 = 27,
2502     D3D12_FEATURE_DISPLAYABLE = 28,
2503     D3D12_FEATURE_D3D12_OPTIONS6 = 30,
2504     D3D12_FEATURE_QUERY_META_COMMAND = 31,
2505     D3D12_FEATURE_D3D12_OPTIONS7 = 32,
2506     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33,
2507     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES = 34,
2508     D3D12_FEATURE_D3D12_OPTIONS8 = 36,
2509     D3D12_FEATURE_D3D12_OPTIONS9 = 37,
2510     D3D12_FEATURE_D3D12_OPTIONS10 = 39,
2511     D3D12_FEATURE_D3D12_OPTIONS11 = 40,
2512     D3D12_FEATURE_D3D12_OPTIONS12 = 41,
2513     D3D12_FEATURE_D3D12_OPTIONS13 = 42,
2514     D3D12_FEATURE_D3D12_OPTIONS14 = 43,
2515     D3D12_FEATURE_D3D12_OPTIONS15 = 44,
2516     D3D12_FEATURE_D3D12_OPTIONS16 = 45,
2517     D3D12_FEATURE_D3D12_OPTIONS17 = 46,
2518     D3D12_FEATURE_D3D12_OPTIONS18 = 47,
2519 } D3D12_FEATURE;
2520
2521 typedef struct D3D12_MEMCPY_DEST
2522 {
2523     void *pData;
2524     SIZE_T RowPitch;
2525     SIZE_T SlicePitch;
2526 } D3D12_MEMCPY_DEST;
2527
2528 typedef struct D3D12_SUBRESOURCE_DATA
2529 {
2530     const void *pData;
2531     LONG_PTR RowPitch;
2532     LONG_PTR SlicePitch;
2533 } D3D12_SUBRESOURCE_DATA;
2534
2535 typedef enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS
2536 {
2537     D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = 0x0,
2538     D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = 0x1,
2539     D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0x0,
2540 } D3D12_MULTIPLE_FENCE_WAIT_FLAGS;
2541 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MULTIPLE_FENCE_WAIT_FLAGS);")
2542
2543 typedef enum D3D12_RESIDENCY_PRIORITY
2544 {
2545     D3D12_RESIDENCY_PRIORITY_MINIMUM = 0x28000000,
2546     D3D12_RESIDENCY_PRIORITY_LOW = 0x50000000,
2547     D3D12_RESIDENCY_PRIORITY_NORMAL = 0x78000000,
2548     D3D12_RESIDENCY_PRIORITY_HIGH = 0xa0010000,
2549     D3D12_RESIDENCY_PRIORITY_MAXIMUM = 0xc8000000,
2550 } D3D12_RESIDENCY_PRIORITY;
2551
2552 typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER
2553 {
2554     D3D12_GPU_VIRTUAL_ADDRESS Dest;
2555     UINT32 Value;
2556 } D3D12_WRITEBUFFERIMMEDIATE_PARAMETER;
2557
2558 typedef enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS
2559 {
2560     D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0,
2561 } D3D12_PROTECTED_RESOURCE_SESSION_FLAGS;
2562 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_FLAGS);")
2563
2564 typedef enum D3D12_PROTECTED_SESSION_STATUS
2565 {
2566     D3D12_PROTECTED_SESSION_STATUS_OK = 0,
2567     D3D12_PROTECTED_SESSION_STATUS_INVALID = 1,
2568 } D3D12_PROTECTED_SESSION_STATUS;
2569
2570 typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC
2571 {
2572     UINT NodeMask;
2573     D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
2574 } D3D12_PROTECTED_RESOURCE_SESSION_DESC;
2575
2576 [
2577     uuid(c4fec28f-7966-4e95-9f94-f431cb56c3b8),
2578     object,
2579     local,
2580     pointer_default(unique)
2581 ]
2582 interface ID3D12Object : IUnknown
2583 {
2584     HRESULT GetPrivateData(REFGUID guid, UINT *data_size, void *data);
2585     HRESULT SetPrivateData(REFGUID guid, UINT data_size, const void *data);
2586     HRESULT SetPrivateDataInterface(REFGUID guid, const IUnknown *data);
2587     HRESULT SetName(const WCHAR *name);
2588 }
2589
2590 [
2591     uuid(905db94b-a00c-4140-9df5-2b64ca9ea357),
2592     object,
2593     local,
2594     pointer_default(unique)
2595 ]
2596 interface ID3D12DeviceChild : ID3D12Object
2597 {
2598     HRESULT GetDevice(REFIID riid, void **device);
2599 }
2600
2601 [
2602     uuid(63ee58fb-1268-4835-86da-f008ce62f0d6),
2603     object,
2604     local,
2605     pointer_default(unique)
2606 ]
2607 interface ID3D12Pageable : ID3D12DeviceChild
2608 {
2609 }
2610
2611 [
2612     uuid(6b3b2502-6e51-45b3-90ee-9884265e8df3),
2613     object,
2614     local,
2615     pointer_default(unique)
2616 ]
2617 interface ID3D12Heap : ID3D12Pageable
2618 {
2619     D3D12_HEAP_DESC GetDesc();
2620 }
2621
2622 [
2623     uuid(696442be-a72e-4059-bc79-5b5c98040fad),
2624     object,
2625     local,
2626     pointer_default(unique)
2627 ]
2628 interface ID3D12Resource : ID3D12Pageable
2629 {
2630     HRESULT Map(UINT sub_resource, const D3D12_RANGE *read_range, void **data);
2631     void Unmap(UINT sub_resource, const D3D12_RANGE *written_range);
2632
2633     D3D12_RESOURCE_DESC GetDesc();
2634
2635     D3D12_GPU_VIRTUAL_ADDRESS GetGPUVirtualAddress();
2636
2637     HRESULT WriteToSubresource(UINT dst_sub_resource, const D3D12_BOX *dst_box,
2638             const void *src_data, UINT src_row_pitch, UINT src_slice_pitch);
2639     HRESULT ReadFromSubresource(void *dst_data, UINT dst_row_pitch, UINT dst_slice_pitch,
2640             UINT src_sub_resource, const D3D12_BOX *src_box);
2641
2642     HRESULT GetHeapProperties(D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS *flags);
2643 }
2644
2645 [
2646     uuid(7116d91c-e7e4-47ce-b8c6-ec8168f437e5),
2647     object,
2648     local,
2649     pointer_default(unique)
2650 ]
2651 interface ID3D12CommandList : ID3D12DeviceChild
2652 {
2653     D3D12_COMMAND_LIST_TYPE GetType();
2654 }
2655
2656 typedef enum D3D12_TILE_COPY_FLAGS
2657 {
2658     D3D12_TILE_COPY_FLAG_NONE = 0x0,
2659     D3D12_TILE_COPY_FLAG_NO_HAZARD = 0x1,
2660     D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2,
2661     D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4,
2662 } D3D12_TILE_COPY_FLAGS;
2663 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_COPY_FLAGS);")
2664
2665 typedef struct D3D12_INDEX_BUFFER_VIEW
2666 {
2667     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
2668     UINT SizeInBytes;
2669     DXGI_FORMAT Format;
2670 } D3D12_INDEX_BUFFER_VIEW;
2671
2672 typedef struct D3D12_VERTEX_BUFFER_VIEW
2673 {
2674     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
2675     UINT SizeInBytes;
2676     UINT StrideInBytes;
2677 } D3D12_VERTEX_BUFFER_VIEW;
2678
2679 typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW
2680 {
2681     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
2682     UINT64 SizeInBytes;
2683     D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation;
2684 } D3D12_STREAM_OUTPUT_BUFFER_VIEW;
2685
2686 typedef enum D3D12_CLEAR_FLAGS
2687 {
2688     D3D12_CLEAR_FLAG_DEPTH = 0x1,
2689     D3D12_CLEAR_FLAG_STENCIL = 0x2,
2690 } D3D12_CLEAR_FLAGS;
2691 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_CLEAR_FLAGS);")
2692
2693 typedef struct D3D12_DISCARD_REGION
2694 {
2695     UINT NumRects;
2696     const D3D12_RECT *pRects;
2697     UINT FirstSubresource;
2698     UINT NumSubresources;
2699 } D3D12_DISCARD_REGION;
2700
2701 typedef enum D3D12_QUERY_TYPE
2702 {
2703     D3D12_QUERY_TYPE_OCCLUSION = 0,
2704     D3D12_QUERY_TYPE_BINARY_OCCLUSION = 1,
2705     D3D12_QUERY_TYPE_TIMESTAMP = 2,
2706     D3D12_QUERY_TYPE_PIPELINE_STATISTICS = 3,
2707     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = 4,
2708     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5,
2709     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6,
2710     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7,
2711     D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = 8,
2712     D3D12_QUERY_TYPE_PIPELINE_STATISTICS1 = 10,
2713 } D3D12_QUERY_TYPE;
2714
2715 typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS
2716 {
2717     UINT64 IAVertices;
2718     UINT64 IAPrimitives;
2719     UINT64 VSInvocations;
2720     UINT64 GSInvocations;
2721     UINT64 GSPrimitives;
2722     UINT64 CInvocations;
2723     UINT64 CPrimitives;
2724     UINT64 PSInvocations;
2725     UINT64 HSInvocations;
2726     UINT64 DSInvocations;
2727     UINT64 CSInvocations;
2728 } D3D12_QUERY_DATA_PIPELINE_STATISTICS;
2729
2730 typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS1
2731 {
2732     UINT64 IAVertices;
2733     UINT64 IAPrimitives;
2734     UINT64 VSInvocations;
2735     UINT64 GSInvocations;
2736     UINT64 GSPrimitives;
2737     UINT64 CInvocations;
2738     UINT64 CPrimitives;
2739     UINT64 PSInvocations;
2740     UINT64 HSInvocations;
2741     UINT64 DSInvocations;
2742     UINT64 CSInvocations;
2743     UINT64 ASInvocations;
2744     UINT64 MSInvocations;
2745     UINT64 MSPrimitives;
2746 } D3D12_QUERY_DATA_PIPELINE_STATISTICS1;
2747
2748 typedef struct D3D12_QUERY_DATA_SO_STATISTICS
2749 {
2750     UINT64 NumPrimitivesWritten;
2751     UINT64 PrimitivesStorageNeeded;
2752 } D3D12_QUERY_DATA_SO_STATISTICS;
2753
2754 typedef enum D3D12_PREDICATION_OP
2755 {
2756     D3D12_PREDICATION_OP_EQUAL_ZERO = 0,
2757     D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = 1,
2758 } D3D12_PREDICATION_OP;
2759
2760 [
2761     uuid(8efb471d-616c-4f49-90f7-127bb763fa51),
2762     object,
2763     local,
2764     pointer_default(unique)
2765 ]
2766 interface ID3D12DescriptorHeap : ID3D12Pageable
2767 {
2768     D3D12_DESCRIPTOR_HEAP_DESC GetDesc();
2769
2770     D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandleForHeapStart();
2771     D3D12_GPU_DESCRIPTOR_HANDLE GetGPUDescriptorHandleForHeapStart();
2772 }
2773
2774 [
2775     uuid(0d9658ae-ed45-469e-a61d-970ec583cab4),
2776     object,
2777     local,
2778     pointer_default(unique)
2779 ]
2780 interface ID3D12QueryHeap : ID3D12Pageable
2781 {
2782 }
2783
2784 [
2785     uuid(c36a797c-ec80-4f0a-8985-a7b2475082d1),
2786     object,
2787     local,
2788     pointer_default(unique)
2789 ]
2790 interface ID3D12CommandSignature : ID3D12Pageable
2791 {
2792 }
2793
2794 [
2795     uuid(5b160d0f-ac1b-4185-8ba8-b3ae42a5a455),
2796     object,
2797     local,
2798     pointer_default(unique)
2799 ]
2800 interface ID3D12GraphicsCommandList : ID3D12CommandList
2801 {
2802     HRESULT Close();
2803
2804     HRESULT Reset(ID3D12CommandAllocator *allocator, ID3D12PipelineState *initial_state);
2805
2806     void ClearState(ID3D12PipelineState *pipeline_state);
2807
2808     void DrawInstanced(UINT vertex_count_per_instance, UINT instance_count,
2809             UINT start_vertex_location, UINT start_instance_location);
2810     void DrawIndexedInstanced(UINT index_count_per_instance, UINT instance_count,
2811             UINT start_vertex_location, INT base_vertex_location, UINT start_instance_location);
2812
2813     void Dispatch(UINT x, UINT u, UINT z);
2814
2815     void CopyBufferRegion(ID3D12Resource *dst_buffer, UINT64 dst_offset,
2816             ID3D12Resource *src_buffer, UINT64 src_offset, UINT64 byte_count);
2817     void CopyTextureRegion(const D3D12_TEXTURE_COPY_LOCATION *dst,
2818             UINT dst_x, UINT dst_y, UINT dst_z,
2819             const D3D12_TEXTURE_COPY_LOCATION *src, const D3D12_BOX *src_box);
2820     void CopyResource(ID3D12Resource *dst_resource, ID3D12Resource *src_resource);
2821
2822     void CopyTiles(ID3D12Resource *tiled_resource,
2823             const D3D12_TILED_RESOURCE_COORDINATE *tile_region_start_coordinate,
2824             const D3D12_TILE_REGION_SIZE *tile_region_size,
2825             ID3D12Resource *buffer,
2826             UINT64 buffer_offset,
2827             D3D12_TILE_COPY_FLAGS flags);
2828
2829     void ResolveSubresource(ID3D12Resource *dst_resource, UINT dst_sub_resource,
2830             ID3D12Resource *src_resource, UINT src_sub_resource,
2831             DXGI_FORMAT format);
2832
2833     void IASetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitive_topology);
2834
2835     void RSSetViewports(UINT viewport_count, const D3D12_VIEWPORT *viewports);
2836     void RSSetScissorRects(UINT rect_count, const D3D12_RECT *rects);
2837
2838     void OMSetBlendFactor(const FLOAT blend_factor[4]);
2839     void OMSetStencilRef(UINT stencil_ref);
2840
2841     void SetPipelineState(ID3D12PipelineState *pipeline_state);
2842
2843     void ResourceBarrier(UINT barrier_count, const D3D12_RESOURCE_BARRIER *barriers);
2844
2845     void ExecuteBundle(ID3D12GraphicsCommandList *command_list);
2846
2847     void SetDescriptorHeaps(UINT heap_count, ID3D12DescriptorHeap * const *heaps);
2848
2849     void SetComputeRootSignature(ID3D12RootSignature *root_signature);
2850     void SetGraphicsRootSignature(ID3D12RootSignature *root_signature);
2851
2852     void SetComputeRootDescriptorTable(UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor);
2853     void SetGraphicsRootDescriptorTable(UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor);
2854
2855     void SetComputeRoot32BitConstant(UINT root_parameter_index, UINT data, UINT dst_offset);
2856     void SetGraphicsRoot32BitConstant(UINT root_parameter_index, UINT data, UINT dst_offset);
2857
2858     void SetComputeRoot32BitConstants(UINT root_parameter_index, UINT constant_count, const void *data,
2859             UINT dst_offset);
2860     void SetGraphicsRoot32BitConstants(UINT root_parameter_index, UINT constant_count, const void *data,
2861             UINT dst_offset);
2862
2863     void SetComputeRootConstantBufferView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2864     void SetGraphicsRootConstantBufferView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2865
2866     void SetComputeRootShaderResourceView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2867     void SetGraphicsRootShaderResourceView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2868
2869     void SetComputeRootUnorderedAccessView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2870     void SetGraphicsRootUnorderedAccessView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2871
2872     void IASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW *view);
2873     void IASetVertexBuffers(UINT start_slot, UINT view_count, const D3D12_VERTEX_BUFFER_VIEW *views);
2874
2875     void SOSetTargets(UINT start_slot, UINT view_count, const D3D12_STREAM_OUTPUT_BUFFER_VIEW *views);
2876
2877     void OMSetRenderTargets(UINT render_target_descriptor_count,
2878             const D3D12_CPU_DESCRIPTOR_HANDLE *render_target_descriptors,
2879             BOOL single_descriptor_handle,
2880             const D3D12_CPU_DESCRIPTOR_HANDLE *depth_stencil_descriptor);
2881
2882     void ClearDepthStencilView(D3D12_CPU_DESCRIPTOR_HANDLE dsv, D3D12_CLEAR_FLAGS flags,
2883             FLOAT depth, UINT8 stencil, UINT rect_count, const D3D12_RECT *rects);
2884     void ClearRenderTargetView(D3D12_CPU_DESCRIPTOR_HANDLE rtv, const FLOAT color[4],
2885             UINT rect_count, const D3D12_RECT *rects);
2886     void ClearUnorderedAccessViewUint(D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle,
2887             D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, const UINT values[4],
2888             UINT rect_count, const D3D12_RECT *rects);
2889     void ClearUnorderedAccessViewFloat(D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle,
2890             D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, const float values[4],
2891             UINT rect_count, const D3D12_RECT *rects);
2892
2893     void DiscardResource(ID3D12Resource *resource, const D3D12_DISCARD_REGION *region);
2894
2895     void BeginQuery(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index);
2896     void EndQuery(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index);
2897     void ResolveQueryData(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type,
2898             UINT start_index, UINT query_count,
2899             ID3D12Resource *dst_buffer, UINT64 aligned_dst_buffer_offset);
2900
2901     void SetPredication(ID3D12Resource *buffer, UINT64 aligned_buffer_offset,
2902             D3D12_PREDICATION_OP operation);
2903
2904     void SetMarker(UINT metadata, const void *data, UINT size);
2905     void BeginEvent(UINT metadata, const void *data, UINT size);
2906     void EndEvent();
2907
2908     void ExecuteIndirect(ID3D12CommandSignature *command_signature,
2909             UINT max_command_count, ID3D12Resource *arg_buffer, UINT64 arg_buffer_offset,
2910             ID3D12Resource *count_buffer, UINT64 count_buffer_offset);
2911 }
2912
2913 [
2914     uuid(553103fb-1fe7-4557-bb38-946d7d0e7ca7),
2915     object,
2916     local,
2917     pointer_default(unique)
2918 ]
2919 interface ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandList
2920 {
2921     void AtomicCopyBufferUINT(ID3D12Resource *dst_buffer, UINT64 dst_offset,
2922             ID3D12Resource *src_buffer, UINT64 src_offset,
2923             UINT dependent_resource_count, ID3D12Resource * const *dependent_resources,
2924             const D3D12_SUBRESOURCE_RANGE_UINT64 *dependent_sub_resource_ranges);
2925
2926     void AtomicCopyBufferUINT64(ID3D12Resource *dst_buffer, UINT64 dst_offset,
2927             ID3D12Resource *src_buffer, UINT64 src_offset,
2928             UINT dependent_resource_count, ID3D12Resource * const *dependent_resources,
2929             const D3D12_SUBRESOURCE_RANGE_UINT64 *dependent_sub_resource_ranges);
2930
2931     void OMSetDepthBounds(FLOAT min, FLOAT max);
2932
2933     void SetSamplePositions(UINT sample_count, UINT pixel_count,
2934             D3D12_SAMPLE_POSITION *sample_positions);
2935
2936     void ResolveSubresourceRegion(ID3D12Resource *dst_resource,
2937             UINT dst_sub_resource_idx, UINT dst_x, UINT dst_y,
2938             ID3D12Resource *src_resource, UINT src_sub_resource_idx,
2939             D3D12_RECT *src_rect, DXGI_FORMAT format, D3D12_RESOLVE_MODE mode);
2940
2941     void SetViewInstanceMask(UINT mask);
2942 }
2943
2944 [
2945     uuid(38c3e585-ff17-412c-9150-4fc6f9d72a28),
2946     object,
2947     local,
2948     pointer_default(unique)
2949 ]
2950 interface ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandList1
2951 {
2952     void WriteBufferImmediate(UINT count,
2953             const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *parameters,
2954             const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes);
2955 }
2956
2957 [
2958     uuid(a1533d18-0ac1-4084-85b9-89a96116806b),
2959     object,
2960     local,
2961     pointer_default(unique)
2962 ]
2963 interface ID3D12ProtectedSession : ID3D12DeviceChild
2964 {
2965     HRESULT GetStatusFence(REFIID riid, void **fence);
2966
2967     D3D12_PROTECTED_SESSION_STATUS GetSessionStatus();
2968 }
2969
2970 typedef enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS
2971 {
2972     D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0x0,
2973     D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1,
2974 } D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS;
2975 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS);")
2976
2977 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT
2978 {
2979     UINT NodeIndex;
2980     D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support;
2981 } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT;
2982
2983 [
2984     uuid(6cd696f4-f289-40cc-8091-5a6c0a099c3d),
2985     object,
2986     local,
2987     pointer_default(unique)
2988 ]
2989 interface ID3D12ProtectedResourceSession : ID3D12ProtectedSession
2990 {
2991     D3D12_PROTECTED_RESOURCE_SESSION_DESC GetDesc();
2992 }
2993
2994 [
2995     uuid(6fda83a7-b84c-4e38-9ac8-c7bd22016b3d),
2996     object,
2997     local,
2998     pointer_default(unique)
2999 ]
3000 interface ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandList2
3001 {
3002     void SetProtectedResourceSession(ID3D12ProtectedResourceSession *protected_resource_session);
3003 }
3004
3005 typedef enum D3D12_TILE_RANGE_FLAGS
3006 {
3007     D3D12_TILE_RANGE_FLAG_NONE = 0x0,
3008     D3D12_TILE_RANGE_FLAG_NULL = 0x1,
3009     D3D12_TILE_RANGE_FLAG_SKIP = 0x2,
3010     D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 0x4
3011 } D3D12_TILE_RANGE_FLAGS;
3012
3013 typedef enum D3D12_TILE_MAPPING_FLAGS
3014 {
3015     D3D12_TILE_MAPPING_FLAG_NONE = 0x0,
3016     D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1,
3017 } D3D12_TILE_MAPPING_FLAGS;
3018 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_MAPPING_FLAGS);")
3019
3020 [
3021     uuid(0ec870a6-5d7e-4c22-8cfc-5baae07616ed),
3022     object,
3023     local,
3024     pointer_default(unique)
3025 ]
3026 interface ID3D12CommandQueue : ID3D12Pageable
3027 {
3028     void UpdateTileMappings(ID3D12Resource *resource, UINT region_count,
3029             const D3D12_TILED_RESOURCE_COORDINATE *region_start_coordinates,
3030             const D3D12_TILE_REGION_SIZE *region_sizes,
3031             ID3D12Heap *heap,
3032             UINT range_count,
3033             const D3D12_TILE_RANGE_FLAGS *range_flags,
3034             const UINT *heap_range_offsets,
3035             const UINT *range_tile_counts,
3036             D3D12_TILE_MAPPING_FLAGS flags);
3037
3038     void CopyTileMappings(ID3D12Resource *dst_resource,
3039             const D3D12_TILED_RESOURCE_COORDINATE *dst_region_start_coordinate,
3040             ID3D12Resource *src_resource,
3041             const D3D12_TILED_RESOURCE_COORDINATE *src_region_start_coordinate,
3042             const D3D12_TILE_REGION_SIZE *region_size,
3043             D3D12_TILE_MAPPING_FLAGS flags);
3044
3045     void ExecuteCommandLists(UINT command_list_count,
3046             ID3D12CommandList * const * command_lists);
3047
3048     void SetMarker(UINT metadata, const void *data, UINT size);
3049     void BeginEvent(UINT metadata, const void *data, UINT size);
3050     void EndEvent();
3051
3052     HRESULT Signal(ID3D12Fence *fence, UINT64 value);
3053     HRESULT Wait(ID3D12Fence *fence, UINT64 value);
3054
3055     HRESULT GetTimestampFrequency(UINT64 *frequency);
3056     HRESULT GetClockCalibration(UINT64 *gpu_timestamp, UINT64 *cpu_timestamp);
3057
3058     D3D12_COMMAND_QUEUE_DESC GetDesc();
3059 }
3060
3061 typedef enum D3D12_FENCE_FLAGS
3062 {
3063     D3D12_FENCE_FLAG_NONE = 0x0,
3064     D3D12_FENCE_FLAG_SHARED = 0x1,
3065     D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2,
3066     D3D12_FENCE_FLAG_NON_MONITORED = 0x4,
3067 } D3D12_FENCE_FLAGS;
3068 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FENCE_FLAGS);")
3069
3070 typedef enum D3D12_QUERY_HEAP_TYPE
3071 {
3072     D3D12_QUERY_HEAP_TYPE_OCCLUSION = 0,
3073     D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1,
3074     D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2,
3075     D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3,
3076     D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = 4,
3077     D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = 5,
3078     D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1 = 7,
3079 } D3D12_QUERY_HEAP_TYPE;
3080
3081 typedef struct D3D12_QUERY_HEAP_DESC
3082 {
3083     D3D12_QUERY_HEAP_TYPE Type;
3084     UINT Count;
3085     UINT NodeMask;
3086 } D3D12_QUERY_HEAP_DESC;
3087
3088 typedef enum D3D12_INDIRECT_ARGUMENT_TYPE
3089 {
3090     D3D12_INDIRECT_ARGUMENT_TYPE_DRAW,
3091     D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED,
3092     D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH,
3093     D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW,
3094     D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW,
3095     D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT,
3096     D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW,
3097     D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW,
3098     D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW,
3099     D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS,
3100     D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH,
3101 } D3D12_INDIRECT_ARGUMENT_TYPE;
3102
3103 typedef struct D3D12_INDIRECT_ARGUMENT_DESC
3104 {
3105     D3D12_INDIRECT_ARGUMENT_TYPE Type;
3106     union
3107     {
3108         struct
3109         {
3110             UINT Slot;
3111         } VertexBuffer;
3112         struct
3113         {
3114             UINT RootParameterIndex;
3115             UINT DestOffsetIn32BitValues;
3116             UINT Num32BitValuesToSet;
3117         } Constant;
3118         struct
3119         {
3120             UINT RootParameterIndex;
3121         } ConstantBufferView;
3122         struct
3123         {
3124             UINT RootParameterIndex;
3125         } ShaderResourceView;
3126         struct
3127         {
3128             UINT RootParameterIndex;
3129         } UnorderedAccessView;
3130     };
3131 } D3D12_INDIRECT_ARGUMENT_DESC;
3132
3133 typedef struct D3D12_COMMAND_SIGNATURE_DESC
3134 {
3135     UINT ByteStride;
3136     UINT NumArgumentDescs;
3137     const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs;
3138     UINT NodeMask;
3139 } D3D12_COMMAND_SIGNATURE_DESC;
3140
3141 [
3142     uuid(c54a6b66-72df-4ee8-8be5-a946a1429214),
3143     object,
3144     local,
3145     pointer_default(unique)
3146 ]
3147 interface ID3D12RootSignature : ID3D12DeviceChild
3148 {
3149 }
3150
3151 [
3152     uuid(765a30f3-f624-4c6f-a828-ace948622445),
3153     object,
3154     local,
3155     pointer_default(unique)
3156 ]
3157 interface ID3D12PipelineState : ID3D12Pageable
3158 {
3159     HRESULT GetCachedBlob(ID3DBlob **blob);
3160 }
3161
3162 [
3163     uuid(0a753dcf-c4d8-4b91-adf6-be5a60d95a76),
3164     object,
3165     local,
3166     pointer_default(unique)
3167 ]
3168 interface ID3D12Fence : ID3D12Pageable
3169 {
3170     UINT64 GetCompletedValue();
3171     HRESULT SetEventOnCompletion(UINT64 value, HANDLE event);
3172     HRESULT Signal(UINT64 value);
3173 }
3174
3175 [
3176     uuid(433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a),
3177     object,
3178     local,
3179     pointer_default(unique)
3180 ]
3181 interface ID3D12Fence1 : ID3D12Fence
3182 {
3183     D3D12_FENCE_FLAGS GetCreationFlags();
3184 }
3185
3186 [
3187     uuid(6102dee4-af59-4b09-b999-b44d73f09b24),
3188     object,
3189     local,
3190     pointer_default(unique)
3191 ]
3192 interface ID3D12CommandAllocator : ID3D12Pageable
3193 {
3194     HRESULT Reset();
3195 }
3196
3197 [
3198     uuid(189819f1-1db6-4b57-be54-1821339b85f7),
3199     object,
3200     local,
3201     pointer_default(unique)
3202 ]
3203 interface ID3D12Device : ID3D12Object
3204 {
3205     UINT GetNodeCount();
3206
3207     HRESULT CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC *desc,
3208             REFIID riid, void **command_queue);
3209     HRESULT CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type,
3210             REFIID riid, void **command_allocator);
3211     HRESULT CreateGraphicsPipelineState(const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc,
3212             REFIID riid, void **pipeline_state);
3213     HRESULT CreateComputePipelineState(const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc,
3214             REFIID riid, void **pipeline_state);
3215     HRESULT CreateCommandList(UINT node_mask,
3216             D3D12_COMMAND_LIST_TYPE type,
3217             ID3D12CommandAllocator *command_allocator,
3218             ID3D12PipelineState *initial_pipeline_state,
3219             REFIID riid, void **command_list);
3220
3221     HRESULT CheckFeatureSupport(D3D12_FEATURE feature,
3222             void *feature_data, UINT feature_data_size);
3223
3224     HRESULT CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DESC *desc,
3225             REFIID riid, void **descriptor_heap);
3226     UINT GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type);
3227
3228     HRESULT CreateRootSignature(UINT node_mask,
3229             const void *bytecode, SIZE_T bytecode_length,
3230             REFIID riid, void **root_signature);
3231
3232     void CreateConstantBufferView(const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc,
3233             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3234     void CreateShaderResourceView(ID3D12Resource *resource,
3235             const D3D12_SHADER_RESOURCE_VIEW_DESC *desc,
3236             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3237     void CreateUnorderedAccessView(ID3D12Resource *resource, ID3D12Resource *counter_resource,
3238             const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc,
3239             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3240     void CreateRenderTargetView(ID3D12Resource *resource,
3241             const D3D12_RENDER_TARGET_VIEW_DESC *desc,
3242             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3243     void CreateDepthStencilView(ID3D12Resource *resource,
3244             const D3D12_DEPTH_STENCIL_VIEW_DESC *desc,
3245             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3246     void CreateSampler(const D3D12_SAMPLER_DESC *desc,
3247             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3248
3249     void CopyDescriptors(UINT dst_descriptor_range_count,
3250             const D3D12_CPU_DESCRIPTOR_HANDLE *dst_descriptor_range_offsets,
3251             const UINT *dst_descriptor_range_sizes,
3252             UINT src_descriptor_range_count,
3253             const D3D12_CPU_DESCRIPTOR_HANDLE *src_descriptor_range_offsets,
3254             const UINT *src_descriptor_range_sizes,
3255             D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type);
3256     void CopyDescriptorsSimple(UINT descriptor_count,
3257             const D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor_range_offset,
3258             const D3D12_CPU_DESCRIPTOR_HANDLE src_descriptor_range_offset,
3259             D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type);
3260
3261     D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo(UINT visible_mask,
3262             UINT reource_desc_count, const D3D12_RESOURCE_DESC *resource_descs);
3263
3264     D3D12_HEAP_PROPERTIES GetCustomHeapProperties(UINT node_mask,
3265             D3D12_HEAP_TYPE heap_type);
3266
3267     HRESULT CreateCommittedResource(const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
3268             const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
3269             const D3D12_CLEAR_VALUE *optimized_clear_value,
3270             REFIID riid, void **resource);
3271
3272     HRESULT CreateHeap(const D3D12_HEAP_DESC *desc, REFIID riid, void **heap);
3273
3274     HRESULT CreatePlacedResource(ID3D12Heap *heap, UINT64 heap_offset,
3275             const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
3276             const D3D12_CLEAR_VALUE *optimized_clear_value,
3277             REFIID riid, void **resource);
3278     HRESULT CreateReservedResource(const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
3279             const D3D12_CLEAR_VALUE *optimized_clear_value,
3280             REFIID riid, void **resource);
3281
3282     HRESULT CreateSharedHandle(ID3D12DeviceChild *object,
3283             const SECURITY_ATTRIBUTES *attributes, DWORD access,
3284             const WCHAR *name, HANDLE *handle);
3285     HRESULT OpenSharedHandle(HANDLE handle,
3286             REFIID riid, void **object);
3287     HRESULT OpenSharedHandleByName(const WCHAR *name, DWORD access, HANDLE *handle);
3288
3289     HRESULT MakeResident(UINT object_count, ID3D12Pageable * const *objects);
3290     HRESULT Evict(UINT object_count, ID3D12Pageable * const *objects);
3291
3292     HRESULT CreateFence(UINT64 initial_value, D3D12_FENCE_FLAGS flags, REFIID riid, void **fence);
3293
3294     HRESULT GetDeviceRemovedReason();
3295
3296     void GetCopyableFootprints(const D3D12_RESOURCE_DESC *desc,
3297             UINT first_sub_resource,
3298             UINT sub_resource_count,
3299             UINT64 base_offset,
3300             D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts,
3301             UINT *row_count,
3302             UINT64 *row_size,
3303             UINT64 *total_bytes);
3304
3305     HRESULT CreateQueryHeap(const D3D12_QUERY_HEAP_DESC *desc,
3306             REFIID riid, void **heap);
3307
3308     HRESULT SetStablePowerState(BOOL enable);
3309
3310     HRESULT CreateCommandSignature(const D3D12_COMMAND_SIGNATURE_DESC *desc,
3311             ID3D12RootSignature *root_signature,
3312             REFIID riid, void **command_signature);
3313
3314     void GetResourceTiling(ID3D12Resource *resource,
3315             UINT *total_tile_count,
3316             D3D12_PACKED_MIP_INFO *packed_mip_info,
3317             D3D12_TILE_SHAPE *standard_tile_shape,
3318             UINT *sub_resource_tiling_count,
3319             UINT first_sub_resource_tiling,
3320             D3D12_SUBRESOURCE_TILING *sub_resource_tilings);
3321
3322     LUID GetAdapterLuid();
3323 }
3324
3325 [
3326     uuid(c64226a8-9201-46af-b4cc-53fb9ff7414f),
3327     object,
3328     local,
3329     pointer_default(unique)
3330 ]
3331 interface ID3D12PipelineLibrary : ID3D12DeviceChild
3332 {
3333     HRESULT StorePipeline(const WCHAR *name, ID3D12PipelineState *pipeline);
3334
3335     HRESULT LoadGraphicsPipeline(const WCHAR *name,
3336             const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, REFIID riid,
3337             void **pipeline_state);
3338
3339     HRESULT LoadComputePipeline(const WCHAR *name,
3340             const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, REFIID riid,
3341             void **pipeline_state);
3342
3343     SIZE_T GetSerializedSize();
3344
3345     HRESULT Serialize(void *data, SIZE_T data_size_in_bytes);
3346 }
3347
3348 [
3349     uuid(80eabf42-2568-4e5e-bd82-c37f86961dc3),
3350     object,
3351     local,
3352     pointer_default(unique)
3353 ]
3354 interface ID3D12PipelineLibrary1 : ID3D12PipelineLibrary
3355 {
3356     HRESULT LoadPipeline(const WCHAR *name,
3357             const D3D12_PIPELINE_STATE_STREAM_DESC *desc, REFIID riid,
3358             void **pipeline_state);
3359 }
3360
3361 [
3362     uuid(77acce80-638e-4e65-8895-c1f23386863e),
3363     object,
3364     local,
3365     pointer_default(unique)
3366 ]
3367 interface ID3D12Device1 : ID3D12Device
3368 {
3369     HRESULT CreatePipelineLibrary(const void *blob, SIZE_T blob_size, REFIID iid, void **lib);
3370
3371     HRESULT SetEventOnMultipleFenceCompletion(ID3D12Fence * const *fences,
3372             const UINT64 *values, UINT fence_count, D3D12_MULTIPLE_FENCE_WAIT_FLAGS flags, HANDLE event);
3373
3374     HRESULT SetResidencyPriority(UINT object_count, ID3D12Pageable * const *objects,
3375             const D3D12_RESIDENCY_PRIORITY *priorities);
3376 }
3377
3378 [
3379     uuid(30baa41e-b15b-475c-a0bb-1af5c5b64328),
3380     object,
3381     local,
3382     pointer_default(unique)
3383 ]
3384 interface ID3D12Device2 : ID3D12Device1
3385 {
3386     HRESULT CreatePipelineState(
3387         [in] const D3D12_PIPELINE_STATE_STREAM_DESC *desc,
3388         [in] REFIID riid,
3389         [out, iid_is(riid)] void **pipeline_state);
3390 }
3391
3392 [
3393     uuid(81dadc15-2bad-4392-93c5-101345c4aa98),
3394     object,
3395     local,
3396     pointer_default(unique)
3397 ]
3398 interface ID3D12Device3 : ID3D12Device2
3399 {
3400     HRESULT OpenExistingHeapFromAddress(
3401         [in] const void *address,
3402         [in] REFIID riid,
3403         [out, iid_is(riid)] void **heap);
3404
3405     HRESULT OpenExistingHeapFromFileMapping(
3406         [in] HANDLE file_mapping,
3407         [in] REFIID riid,
3408         [out, iid_is(riid)] void **heap);
3409
3410     HRESULT EnqueueMakeResident(
3411         [in] D3D12_RESIDENCY_FLAGS flags,
3412         [in] UINT num_objects,
3413         [in] ID3D12Pageable *const *objects,
3414         [in] ID3D12Fence *fence,
3415         [in] UINT64 fence_value);
3416 }
3417
3418 [
3419     uuid(34ab647b-3cc8-46ac-841b-c0965645c046),
3420     object,
3421     local,
3422     pointer_default(unique)
3423 ]
3424 interface ID3D12RootSignatureDeserializer : IUnknown
3425 {
3426     const D3D12_ROOT_SIGNATURE_DESC *GetRootSignatureDesc();
3427 }
3428
3429 [
3430     uuid(7f91ce67-090c-4bb7-b78e-ed8ff2e31da0),
3431     object,
3432     local,
3433     pointer_default(unique)
3434 ]
3435 interface ID3D12VersionedRootSignatureDeserializer : IUnknown
3436 {
3437     HRESULT GetRootSignatureDescAtVersion(D3D_ROOT_SIGNATURE_VERSION version,
3438             const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **desc);
3439
3440     const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *GetUnconvertedRootSignatureDesc();
3441 };
3442
3443 typedef enum D3D12_COMMAND_LIST_FLAGS
3444 {
3445     D3D12_COMMAND_LIST_FLAG_NONE = 0x0,
3446 } D3D12_COMMAND_LIST_FLAGS;
3447 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_FLAGS);")
3448
3449 typedef enum D3D12_COMMAND_POOL_FLAGS
3450 {
3451     D3D12_COMMAND_POOL_FLAG_NONE = 0x0,
3452 } D3D12_COMMAND_POOL_FLAGS;
3453 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_POOL_FLAGS);")
3454
3455 typedef enum D3D12_COMMAND_RECORDER_FLAGS
3456 {
3457     D3D12_COMMAND_RECORDER_FLAG_NONE = 0x0,
3458 } D3D12_COMMAND_RECORDER_FLAGS;
3459 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_RECORDER_FLAGS);")
3460
3461 [
3462     uuid(e865df17-a9ee-46f9-a463-3098315aa2e5),
3463     object,
3464     local,
3465     pointer_default(unique)
3466 ]
3467 interface ID3D12Device4 : ID3D12Device3
3468 {
3469     HRESULT CreateCommandList1(
3470             UINT node_mask, D3D12_COMMAND_LIST_TYPE type,
3471             D3D12_COMMAND_LIST_FLAGS flags, REFIID riid,
3472             void **command_list);
3473
3474     HRESULT CreateProtectedResourceSession(
3475             const D3D12_PROTECTED_RESOURCE_SESSION_DESC *desc, REFIID riid,
3476             void **session);
3477
3478     HRESULT CreateCommittedResource1(
3479             const D3D12_HEAP_PROPERTIES *heap_properties,
3480             D3D12_HEAP_FLAGS heap_flags,
3481             const D3D12_RESOURCE_DESC *desc,
3482             D3D12_RESOURCE_STATES initial_resource_state,
3483             const D3D12_CLEAR_VALUE *optimized_clear_value,
3484             ID3D12ProtectedResourceSession *protected_session,
3485             REFIID riid_resource,
3486             void **resource);
3487
3488     HRESULT CreateHeap1(
3489             const D3D12_HEAP_DESC *desc,
3490             ID3D12ProtectedResourceSession *protected_session,
3491             REFIID riid, void **heap);
3492
3493     HRESULT CreateReservedResource1(
3494             const D3D12_RESOURCE_DESC *desc,
3495             D3D12_RESOURCE_STATES initial_state,
3496             const D3D12_CLEAR_VALUE *optimized_clear_value,
3497             ID3D12ProtectedResourceSession *protected_session,
3498             REFIID riid, void **resource);
3499
3500     D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo1(
3501             UINT visible_mask,
3502             UINT resource_descs_count,
3503             const D3D12_RESOURCE_DESC *resource_descs,
3504             D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1);
3505 }
3506
3507 typedef enum D3D12_LIFETIME_STATE
3508 {
3509     D3D12_LIFETIME_STATE_IN_USE = 0x0,
3510     D3D12_LIFETIME_STATE_NOT_IN_USE = 0x1,
3511 } D3D12_LIFETIME_STATE;
3512
3513 [
3514     uuid(e667af9f-cd56-4f46-83ce-032e595d70a8),
3515     object,
3516     local,
3517     pointer_default(unique)
3518 ]
3519 interface ID3D12LifetimeOwner : IUnknown
3520 {
3521     void LifetimeStateUpdated(D3D12_LIFETIME_STATE NewState);
3522 }
3523
3524 [
3525     uuid(f1df64b6-57fd-49cd-8807-c0eb88b45c8f),
3526     object,
3527     local,
3528     pointer_default(unique)
3529 ]
3530 interface ID3D12SwapChainAssistant : IUnknown
3531 {
3532     LUID GetLUID();
3533     HRESULT GetSwapChainObject(REFIID riid, void **ppv);
3534     HRESULT GetCurrentResourceAndCommandQueue(
3535             REFIID riid_resource, void **resource,
3536             REFIID riid_queue, void **queue);
3537     HRESULT InsertImplicitSync();
3538 }
3539
3540 [
3541     uuid(3fd03d36-4eb1-424a-a582-494ecb8ba813),
3542     object,
3543     local,
3544     pointer_default(unique)
3545 ]
3546 interface ID3D12LifetimeTracker : ID3D12DeviceChild
3547 {
3548     HRESULT DestroyOwnedObject(ID3D12DeviceChild *object);
3549 }
3550
3551 typedef enum D3D12_META_COMMAND_PARAMETER_TYPE
3552 {
3553     D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = 0x0,
3554     D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = 0x1,
3555     D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = 0x2,
3556     D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x3,
3557     D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x4,
3558 } D3D12_META_COMMAND_PARAMETER_TYPE;
3559
3560 typedef enum D3D12_META_COMMAND_PARAMETER_FLAGS
3561 {
3562     D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 0x1,
3563     D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2,
3564 } D3D12_META_COMMAND_PARAMETER_FLAGS;
3565 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_META_COMMAND_PARAMETER_FLAGS);")
3566
3567 typedef enum D3D12_META_COMMAND_PARAMETER_STAGE
3568 {
3569     D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = 0x0,
3570     D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = 0x1,
3571     D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = 0x2,
3572 } D3D12_META_COMMAND_PARAMETER_STAGE;
3573
3574 typedef struct D3D12_META_COMMAND_PARAMETER_DESC
3575 {
3576     const WCHAR *Name;
3577     D3D12_META_COMMAND_PARAMETER_TYPE Type;
3578     D3D12_META_COMMAND_PARAMETER_FLAGS Flags;
3579     D3D12_RESOURCE_STATES RequiredResourceState;
3580     UINT StructureOffset;
3581 } D3D12_META_COMMAND_PARAMETER_DESC;
3582
3583 typedef enum D3D12_GRAPHICS_STATES
3584 {
3585     D3D12_GRAPHICS_STATE_NONE = 0x0,
3586     D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = 0x1,
3587     D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = 0x2,
3588     D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = 0x4,
3589     D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = 0x8,
3590     D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = 0x10,
3591     D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = 0x20,
3592     D3D12_GRAPHICS_STATE_RS_VIEWPORTS = 0x40,
3593     D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = 0x80,
3594     D3D12_GRAPHICS_STATE_PREDICATION = 0x100,
3595     D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = 0x200,
3596     D3D12_GRAPHICS_STATE_OM_STENCIL_REF = 0x400,
3597     D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = 0x800,
3598     D3D12_GRAPHICS_STATE_PIPELINE_STATE = 0x1000,
3599     D3D12_GRAPHICS_STATE_SO_TARGETS = 0x2000,
3600     D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = 0x4000,
3601     D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = 0x8000,
3602     D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = 0x10000,
3603 } D3D12_GRAPHICS_STATES;
3604 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GRAPHICS_STATES);")
3605
3606 typedef struct D3D12_META_COMMAND_DESC
3607 {
3608     GUID Id;
3609     const WCHAR *Name;
3610     D3D12_GRAPHICS_STATES InitializationDirtyState;
3611     D3D12_GRAPHICS_STATES ExecutionDirtyState;
3612 } D3D12_META_COMMAND_DESC;
3613
3614 [
3615     uuid(47016943-fca8-4594-93ea-af258b55346d),
3616     object,
3617     local,
3618     pointer_default(unique)
3619 ]
3620 interface ID3D12StateObject : ID3D12Pageable
3621 {
3622 }
3623
3624 [
3625     uuid(de5fa827-9bf9-4f26-89ff-d7f56fde3860),
3626     object,
3627     local,
3628     pointer_default(unique)
3629 ]
3630 interface ID3D12StateObjectProperties : IUnknown
3631 {
3632     void *GetShaderIdentifier(const WCHAR *export_name);
3633     UINT64 GetShaderStackSize(const WCHAR *export_name);
3634     UINT64 GetPipelineStackSize();
3635     void SetPipelineStackSize(UINT64 pipeline_stack_size_in_bytes);
3636 }
3637
3638 typedef enum D3D12_STATE_SUBOBJECT_TYPE
3639 {
3640     D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0x0,
3641     D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 0x1,
3642     D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 0x2,
3643     D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x3,
3644     D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 0x5,
3645     D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 0x6,
3646     D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x7,
3647     D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x8,
3648     D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 0x9,
3649     D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 0xa,
3650     D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 0xb,
3651     D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = 0xc,
3652     D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = 0xd,
3653 } D3D12_STATE_SUBOBJECT_TYPE;
3654
3655 typedef struct D3D12_STATE_SUBOBJECT
3656 {
3657     D3D12_STATE_SUBOBJECT_TYPE Type;
3658     const void *pDesc;
3659 } D3D12_STATE_SUBOBJECT;
3660
3661 typedef enum D3D12_STATE_OBJECT_FLAGS
3662 {
3663     D3D12_STATE_OBJECT_FLAG_NONE = 0x0,
3664     D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1,
3665     D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2,
3666     D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4,
3667 } D3D12_STATE_OBJECT_FLAGS;
3668 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_STATE_OBJECT_FLAGS);")
3669
3670 typedef struct D3D12_STATE_OBJECT_CONFIG
3671 {
3672     D3D12_STATE_OBJECT_FLAGS Flags;
3673 } D3D12_STATE_OBJECT_CONFIG;
3674
3675 typedef struct D3D12_GLOBAL_ROOT_SIGNATURE
3676 {
3677     ID3D12RootSignature *pGlobalRootSignature;
3678 } D3D12_GLOBAL_ROOT_SIGNATURE;
3679
3680 typedef struct D3D12_LOCAL_ROOT_SIGNATURE
3681 {
3682     ID3D12RootSignature *pLocalRootSignature;
3683 } D3D12_LOCAL_ROOT_SIGNATURE;
3684
3685 typedef struct D3D12_NODE_MASK
3686 {
3687     UINT NodeMask;
3688 } D3D12_NODE_MASK;
3689
3690 typedef enum D3D12_EXPORT_FLAGS
3691 {
3692     D3D12_EXPORT_FLAG_NONE = 0x0,
3693 } D3D12_EXPORT_FLAGS;
3694 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_EXPORT_FLAGS);")
3695
3696 typedef struct D3D12_EXPORT_DESC
3697 {
3698     const WCHAR *Name;
3699     const WCHAR *ExportToRename;
3700     D3D12_EXPORT_FLAGS Flags;
3701 } D3D12_EXPORT_DESC;
3702
3703 typedef struct D3D12_DXIL_LIBRARY_DESC
3704 {
3705     D3D12_SHADER_BYTECODE DXILLibrary;
3706     UINT NumExports;
3707     D3D12_EXPORT_DESC *pExports;
3708 } D3D12_DXIL_LIBRARY_DESC;
3709
3710 typedef struct D3D12_EXISTING_COLLECTION_DESC
3711 {
3712     ID3D12StateObject *pExistingCollection;
3713     UINT NumExports;
3714     D3D12_EXPORT_DESC *pExports;
3715 } D3D12_EXISTING_COLLECTION_DESC;
3716
3717 typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION
3718 {
3719     const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate;
3720     UINT NumExports;
3721     const WCHAR **pExports;
3722 } D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3723
3724 typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
3725 {
3726     const WCHAR *SubobjectToAssociate;
3727     UINT NumExports;
3728     const WCHAR **pExports;
3729 } D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3730
3731 typedef enum D3D12_HIT_GROUP_TYPE
3732 {
3733     D3D12_HIT_GROUP_TYPE_TRIANGLES = 0x0,
3734     D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1,
3735 } D3D12_HIT_GROUP_TYPE;
3736
3737 typedef struct D3D12_HIT_GROUP_DESC
3738 {
3739     const WCHAR *HitGroupExport;
3740     D3D12_HIT_GROUP_TYPE Type;
3741     const WCHAR *AnyHitShaderImport;
3742     const WCHAR *ClosestHitShaderImport;
3743     const WCHAR *IntersectionShaderImport;
3744 } D3D12_HIT_GROUP_DESC;
3745
3746 typedef struct D3D12_RAYTRACING_SHADER_CONFIG
3747 {
3748     UINT MaxPayloadSizeInBytes;
3749     UINT MaxAttributeSizeInBytes;
3750 } D3D12_RAYTRACING_SHADER_CONFIG;
3751
3752 typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG
3753 {
3754     UINT MaxTraceRecursionDepth;
3755 } D3D12_RAYTRACING_PIPELINE_CONFIG;
3756
3757 typedef enum D3D12_RAYTRACING_PIPELINE_FLAGS
3758 {
3759     D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0x0,
3760     D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100,
3761     D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200,
3762 } D3D12_RAYTRACING_PIPELINE_FLAGS;
3763 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_PIPELINE_FLAGS);")
3764
3765 typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1
3766 {
3767     UINT MaxTraceRecursionDepth;
3768     D3D12_RAYTRACING_PIPELINE_FLAGS Flags;
3769 } D3D12_RAYTRACING_PIPELINE_CONFIG1;
3770
3771 typedef enum D3D12_STATE_OBJECT_TYPE
3772 {
3773     D3D12_STATE_OBJECT_TYPE_COLLECTION = 0x0,
3774     D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 0x3,
3775 } D3D12_STATE_OBJECT_TYPE;
3776
3777 typedef struct D3D12_STATE_OBJECT_DESC
3778 {
3779     D3D12_STATE_OBJECT_TYPE Type;
3780     UINT NumSubobjects;
3781     const D3D12_STATE_SUBOBJECT *pSubobjects;
3782 } D3D12_STATE_OBJECT_DESC;
3783
3784 typedef enum D3D12_RAYTRACING_GEOMETRY_FLAGS
3785 {
3786     D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0x0,
3787     D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1,
3788     D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2,
3789 } D3D12_RAYTRACING_GEOMETRY_FLAGS;
3790 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_GEOMETRY_FLAGS);")
3791
3792 typedef enum D3D12_RAYTRACING_GEOMETRY_TYPE
3793 {
3794     D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0x0,
3795     D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = 0x1,
3796 } D3D12_RAYTRACING_GEOMETRY_TYPE;
3797
3798 typedef enum D3D12_RAYTRACING_INSTANCE_FLAGS
3799 {
3800     D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0x0,
3801     D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1,
3802     D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2,
3803     D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4,
3804     D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8
3805 } D3D12_RAYTRACING_INSTANCE_FLAGS;
3806 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_INSTANCE_FLAGS);")
3807
3808 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE
3809 {
3810     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
3811     UINT64 StrideInBytes;
3812 } D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE;
3813
3814 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE
3815 {
3816     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
3817     UINT64 SizeInBytes;
3818 } D3D12_GPU_VIRTUAL_ADDRESS_RANGE;
3819
3820 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE
3821 {
3822     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
3823     UINT64 SizeInBytes;
3824     UINT64 StrideInBytes;
3825 } D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE;
3826
3827 typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC
3828 {
3829     D3D12_GPU_VIRTUAL_ADDRESS Transform3x4;
3830     DXGI_FORMAT IndexFormat;
3831     DXGI_FORMAT VertexFormat;
3832     UINT IndexCount;
3833     UINT VertexCount;
3834     D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer;
3835     D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer;
3836 } D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC;
3837
3838 typedef struct D3D12_RAYTRACING_AABB
3839 {
3840     FLOAT MinX;
3841     FLOAT MinY;
3842     FLOAT MinZ;
3843     FLOAT MaxX;
3844     FLOAT MaxY;
3845     FLOAT MaxZ;
3846 } D3D12_RAYTRACING_AABB;
3847
3848 typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC
3849 {
3850     UINT64 AABBCount;
3851     D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs;
3852 } D3D12_RAYTRACING_GEOMETRY_AABBS_DESC;
3853
3854 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS
3855 {
3856     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0x00,
3857     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x01,
3858     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x02,
3859     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x04,
3860     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x08,
3861     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10,
3862     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20,
3863 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
3864 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS);")
3865
3866 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE
3867 {
3868     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0x0,
3869     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1,
3870     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2,
3871     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3,
3872     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4,
3873 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE;
3874
3875 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE
3876 {
3877     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0x0,
3878     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1
3879 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE;
3880
3881 typedef enum D3D12_ELEMENTS_LAYOUT
3882 {
3883     D3D12_ELEMENTS_LAYOUT_ARRAY = 0x0,
3884     D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1
3885 } D3D12_ELEMENTS_LAYOUT;
3886
3887 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE
3888 {
3889     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0x0,
3890     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION  = 0x1,
3891     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION  = 0x2,
3892     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE  = 0x3,
3893 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE;
3894
3895 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC
3896 {
3897     D3D12_GPU_VIRTUAL_ADDRESS DestBuffer;
3898     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType;
3899 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC;
3900
3901 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC
3902 {
3903     UINT64 CompactedSizeInBytes;
3904 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC;
3905
3906 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC
3907 {
3908     UINT64 DecodedSizeInBytes;
3909 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC;
3910
3911 typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER
3912 {
3913     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
3914     UINT NumDescs;
3915 } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER;
3916
3917 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC
3918 {
3919     UINT64 SerializedSizeInBytes;
3920     UINT64 NumBottomLevelAccelerationStructurePointers;
3921 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC;
3922
3923 typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER
3924 {
3925     GUID DriverOpaqueGUID;
3926     BYTE DriverOpaqueVersioningData[16];
3927 } D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER;
3928
3929 typedef enum D3D12_SERIALIZED_DATA_TYPE
3930 {
3931     D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0x0,
3932 } D3D12_SERIALIZED_DATA_TYPE;
3933
3934 typedef enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS
3935 {
3936     D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0x0,
3937     D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1,
3938     D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2,
3939     D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3,
3940     D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4,
3941 } D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS;
3942
3943 typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER
3944 {
3945     D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier;
3946     UINT64 SerializedSizeInBytesIncludingHeader;
3947     UINT64 DeserializedSizeInBytes;
3948     UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader;
3949 } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER;
3950
3951 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC
3952 {
3953     UINT64 CurrentSizeInBytes;
3954 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC;
3955
3956 typedef struct D3D12_RAYTRACING_INSTANCE_DESC
3957 {
3958     FLOAT Transform[3][4];
3959     UINT InstanceID : 24;
3960     UINT InstanceMask : 8;
3961     UINT InstanceContributionToHitGroupIndex : 24;
3962     UINT Flags : 8;
3963     D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure;
3964 } D3D12_RAYTRACING_INSTANCE_DESC;
3965
3966 typedef struct D3D12_RAYTRACING_GEOMETRY_DESC
3967 {
3968     D3D12_RAYTRACING_GEOMETRY_TYPE Type;
3969     D3D12_RAYTRACING_GEOMETRY_FLAGS Flags;
3970     union
3971     {
3972         D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles;
3973         D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs;
3974     };
3975 } D3D12_RAYTRACING_GEOMETRY_DESC;
3976
3977 typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS
3978 {
3979     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
3980     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags;
3981     UINT NumDescs;
3982     D3D12_ELEMENTS_LAYOUT DescsLayout;
3983     union
3984     {
3985         D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs;
3986         const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs;
3987         const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs;
3988     };
3989 } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS;
3990
3991 typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC
3992 {
3993     D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData;
3994     D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs;
3995     D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData;
3996     D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData;
3997 } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC;
3998
3999 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO
4000 {
4001     UINT64 ResultDataMaxSizeInBytes;
4002     UINT64 ScratchDataSizeInBytes;
4003     UINT64 UpdateScratchDataSizeInBytes;
4004 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO;
4005
4006 typedef enum D3D12_RAY_FLAGS
4007 {
4008     D3D12_RAY_FLAG_NONE = 0x00,
4009     D3D12_RAY_FLAG_FORCE_OPAQUE = 0x01,
4010     D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x02,
4011     D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x04,
4012     D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x08,
4013     D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10,
4014     D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20,
4015     D3D12_RAY_FLAG_CULL_OPAQUE = 0x40,
4016     D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80,
4017     D3D12_RAY_FLAG_SKIP_TRIANGLES = 0x100,
4018     D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200,
4019 } D3D12_RAY_FLAGS;
4020 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAY_FLAGS);")
4021
4022 typedef enum D3D12_HIT_KIND
4023 {
4024     D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe,
4025     D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff,
4026 } D3D12_HIT_KIND;
4027
4028 [
4029     uuid(8b4f173b-2fea-4b80-8f58-4307191ab95d),
4030     object,
4031     local,
4032     pointer_default(unique)
4033 ]
4034 interface ID3D12Device5 : ID3D12Device4
4035 {
4036     HRESULT CreateLifetimeTracker(
4037             ID3D12LifetimeOwner *owner, REFIID riid,
4038             void **tracker);
4039
4040     void RemoveDevice();
4041
4042     HRESULT EnumerateMetaCommands(
4043             UINT *meta_commands_count,
4044             D3D12_META_COMMAND_DESC *descs);
4045
4046     HRESULT EnumerateMetaCommandParameters(
4047             REFGUID command_id,
4048             D3D12_META_COMMAND_PARAMETER_STAGE stage,
4049             UINT *total_structure_size_in_bytes,
4050             UINT *parameter_count,
4051             D3D12_META_COMMAND_PARAMETER_DESC *parameter_descs);
4052
4053     HRESULT CreateMetaCommand(
4054             REFGUID command_id, UINT node_mask,
4055             const void *creation_parameters_data,
4056             SIZE_T creation_parameters_data_size_in_bytes,
4057             REFIID riid, void **meta_command);
4058
4059     HRESULT CreateStateObject(
4060             const D3D12_STATE_OBJECT_DESC *desc, REFIID riid,
4061             void **state_object);
4062
4063     void GetRaytracingAccelerationStructurePrebuildInfo(
4064             const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *desc,
4065             D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *info);
4066
4067     D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS CheckDriverMatchingIdentifier(
4068             D3D12_SERIALIZED_DATA_TYPE serialized_data_type,
4069             const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *identifier_to_check);
4070 }
4071
4072 typedef enum D3D12_AUTO_BREADCRUMB_OP
4073 {
4074     D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0x0,
4075     D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 0x1,
4076     D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 0x2,
4077     D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 0x3,
4078     D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 0x4,
4079     D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 0x5,
4080     D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 0x6,
4081     D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 0x7,
4082     D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 0x8,
4083     D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 0x9,
4084     D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 0xa,
4085     D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 0xb,
4086     D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 0xc,
4087     D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 0xd,
4088     D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 0xe,
4089     D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 0xf,
4090     D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 0x10,
4091     D3D12_AUTO_BREADCRUMB_OP_PRESENT = 0x11,
4092     D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 0x12,
4093     D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 0x13,
4094     D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 0x14,
4095     D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 0x15,
4096     D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 0x16,
4097     D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 0x17,
4098     D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 0x18,
4099     D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 0x19,
4100     D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 0x1a,
4101     D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 0x1b,
4102     D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 0x1c,
4103     D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 0x1d,
4104     D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 0x1e,
4105     D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 0x1f,
4106     D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 0x20,
4107     D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 0x21,
4108     D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 0x22,
4109     D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 0x23,
4110     D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 0x24,
4111     D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 0x25,
4112     D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 0x26,
4113     D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 0x27,
4114     D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 0x28,
4115     D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 0x29,
4116     D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = 0x2a,
4117     D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = 0x2b,
4118     D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = 0x2c,
4119 } D3D12_AUTO_BREADCRUMB_OP;
4120
4121 typedef struct D3D12_AUTO_BREADCRUMB_NODE
4122 {
4123     const char *pCommandListDebugNameA;
4124     const WCHAR *pCommandListDebugNameW;
4125     const char *pCommandQueueDebugNameA;
4126     const WCHAR *pCommandQueueDebugNameW;
4127     ID3D12GraphicsCommandList *pCommandList;
4128     ID3D12CommandQueue *pCommandQueue;
4129     UINT32 BreadcrumbCount;
4130     const UINT32 *pLastBreadcrumbValue;
4131     const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
4132     const struct D3D12_AUTO_BREADCRUMB_NODE *pNext;
4133 } D3D12_AUTO_BREADCRUMB_NODE;
4134
4135 typedef struct D3D12_DRED_BREADCRUMB_CONTEXT
4136 {
4137     UINT BreadcrumbIndex;
4138     const WCHAR *pContextString;
4139 } D3D12_DRED_BREADCRUMB_CONTEXT;
4140
4141 typedef struct D3D12_AUTO_BREADCRUMB_NODE1
4142 {
4143     const char *pCommandListDebugNameA;
4144     const WCHAR *pCommandListDebugNameW;
4145     const char *pCommandQueueDebugNameA;
4146     const WCHAR *pCommandQueueDebugNameW;
4147     ID3D12GraphicsCommandList *pCommandList;
4148     ID3D12CommandQueue *pCommandQueue;
4149     UINT BreadcrumbCount;
4150     const UINT *pLastBreadcrumbValue;
4151     const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
4152     const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext;
4153     UINT BreadcrumbContextsCount;
4154     D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts;
4155 } D3D12_AUTO_BREADCRUMB_NODE1;
4156
4157 typedef enum D3D12_DRED_VERSION
4158 {
4159     D3D12_DRED_VERSION_1_0 = 0x1,
4160     D3D12_DRED_VERSION_1_1 = 0x2,
4161     D3D12_DRED_VERSION_1_2 = 0x3,
4162     D3D12_DRED_VERSION_1_3 = 0x4,
4163 } D3D12_DRED_VERSION;
4164
4165 typedef enum D3D12_DRED_FLAGS
4166 {
4167     D3D12_DRED_FLAG_NONE = 0x0,
4168     D3D12_DRED_FLAG_FORCE_ENABLE = 0x1,
4169     D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 0x2,
4170 } D3D12_DRED_FLAGS;
4171 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_FLAGS);")
4172
4173 typedef enum D3D12_DRED_ENABLEMENT
4174 {
4175     D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0x0,
4176     D3D12_DRED_ENABLEMENT_FORCED_OFF = 0x1,
4177     D3D12_DRED_ENABLEMENT_FORCED_ON = 0x2,
4178 } D3D12_DRED_ENABLEMENT;
4179
4180 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA
4181 {
4182     D3D12_DRED_FLAGS Flags;
4183     D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
4184 } D3D12_DEVICE_REMOVED_EXTENDED_DATA;
4185
4186 typedef enum D3D12_DRED_ALLOCATION_TYPE
4187 {
4188     D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 0x13,
4189     D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 0x14,
4190     D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 0x15,
4191     D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 0x16,
4192     D3D12_DRED_ALLOCATION_TYPE_FENCE = 0x17,
4193     D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 0x18,
4194     D3D12_DRED_ALLOCATION_TYPE_HEAP = 0x19,
4195     D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 0x1b,
4196     D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 0x1c,
4197     D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 0x1d,
4198     D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 0x1e,
4199     D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 0x20,
4200     D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 0x22,
4201     D3D12_DRED_ALLOCATION_TYPE_PASS = 0x23,
4202     D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 0x24,
4203     D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 0x25,
4204     D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 0x26,
4205     D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 0x27,
4206     D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 0x28,
4207     D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 0x29,
4208     D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 0x2a,
4209     D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 0x2b,
4210     D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 0x2c,
4211     D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 0x2d,
4212     D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 0x2e,
4213     D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 0x2f,
4214     D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = 0x30,
4215     D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = 0x31,
4216     D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff,
4217 } D3D12_DRED_ALLOCATION_TYPE;
4218
4219 typedef struct D3D12_DRED_ALLOCATION_NODE
4220 {
4221     const char *ObjectNameA;
4222     const WCHAR *ObjectNameW;
4223     D3D12_DRED_ALLOCATION_TYPE AllocationType;
4224     const struct D3D12_DRED_ALLOCATION_NODE *pNext;
4225 } D3D12_DRED_ALLOCATION_NODE;
4226
4227 typedef struct D3D12_DRED_ALLOCATION_NODE1
4228 {
4229     const char *ObjectNameA;
4230     const WCHAR *ObjectNameW;
4231     D3D12_DRED_ALLOCATION_TYPE AllocationType;
4232     const struct D3D12_DRED_ALLOCATION_NODE1 *pNext;
4233     const IUnknown *pObject;
4234 } D3D12_DRED_ALLOCATION_NODE1;
4235
4236 typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT
4237 {
4238     const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
4239 } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT;
4240
4241 typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1
4242 {
4243     const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode;
4244 } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1;
4245
4246 typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT
4247 {
4248     D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
4249     const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode;
4250     const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode;
4251 } D3D12_DRED_PAGE_FAULT_OUTPUT;
4252
4253 typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1
4254 {
4255     D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
4256     const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
4257     const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
4258 } D3D12_DRED_PAGE_FAULT_OUTPUT1;
4259
4260 typedef enum D3D12_DRED_PAGE_FAULT_FLAGS
4261 {
4262     D3D12_DRED_PAGE_FAULT_FLAGS_NONE = 0x0,
4263 } D3D12_DRED_PAGE_FAULT_FLAGS;
4264 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_PAGE_FAULT_FLAGS);")
4265
4266 typedef enum D3D12_DRED_DEVICE_STATE
4267 {
4268     D3D12_DRED_DEVICE_STATE_UNKNOWN = 0x0,
4269     D3D12_DRED_DEVICE_STATE_HUNG = 0x3,
4270     D3D12_DRED_DEVICE_STATE_FAULT = 0x6,
4271     D3D12_DRED_DEVICE_STATE_PAGEFAULT = 0x7,
4272 } D3D12_DRED_DEVICE_STATE;
4273
4274 typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2
4275 {
4276     D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
4277     const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
4278     const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
4279     D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags;
4280 } D3D12_DRED_PAGE_FAULT_OUTPUT2;
4281
4282 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1
4283 {
4284     HRESULT DeviceRemovedReason;
4285     D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput;
4286     D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput;
4287 } D3D12_DEVICE_REMOVED_EXTENDED_DATA1;
4288
4289 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2
4290 {
4291     HRESULT DeviceRemovedReason;
4292     D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
4293     D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput;
4294 } D3D12_DEVICE_REMOVED_EXTENDED_DATA2;
4295
4296 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3
4297 {
4298     HRESULT DeviceRemovedReason;
4299     D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
4300     D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput;
4301     D3D12_DRED_DEVICE_STATE DeviceState;
4302 } D3D12_DEVICE_REMOVED_EXTENDED_DATA3;
4303
4304 typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA
4305 {
4306     D3D12_DRED_VERSION Version;
4307     union
4308     {
4309         D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0;
4310         D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1;
4311         D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2;
4312         D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3;
4313     };
4314 } D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA;
4315
4316 [
4317     uuid(82bc481c-6b9b-4030-aedb-7ee3d1df1e63),
4318     object,
4319     local,
4320     pointer_default(unique)
4321 ]
4322 interface ID3D12DeviceRemovedExtendedDataSettings : IUnknown
4323 {
4324     void SetAutoBreadcrumbsEnablement(D3D12_DRED_ENABLEMENT enablement);
4325     void SetPageFaultEnablement(D3D12_DRED_ENABLEMENT enablement);
4326     void SetWatsonDumpEnablement(D3D12_DRED_ENABLEMENT enablement);
4327 }
4328
4329 [
4330     uuid(dbd5ae51-3317-4f0a-adf9-1d7cedcaae0b),
4331     object,
4332     local,
4333     pointer_default(unique)
4334 ]
4335 interface ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12DeviceRemovedExtendedDataSettings
4336 {
4337     void SetBreadcrumbContextEnablement(D3D12_DRED_ENABLEMENT enablement);
4338 }
4339
4340 [
4341     uuid(98931d33-5ae8-4791-aa3c-1a73a2934e71),
4342     object,
4343     local,
4344     pointer_default(unique)
4345 ]
4346 interface ID3D12DeviceRemovedExtendedData : IUnknown
4347 {
4348     HRESULT GetAutoBreadcrumbsOutput(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *output);
4349     HRESULT GetPageFaultAllocationOutput(D3D12_DRED_PAGE_FAULT_OUTPUT *output);
4350 }
4351
4352 [
4353     uuid(9727a022-cf1d-4dda-9eba-effa653fc506),
4354     object,
4355     local,
4356     pointer_default(unique)
4357 ]
4358 interface ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemovedExtendedData
4359 {
4360     HRESULT GetAutoBreadcrumbsOutput1(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *output);
4361     HRESULT GetPageFaultAllocationOutput1(D3D12_DRED_PAGE_FAULT_OUTPUT1 *output);
4362 }
4363
4364 [
4365     uuid(67fc5816-e4ca-4915-bf18-42541272da54),
4366     object,
4367     local,
4368     pointer_default(unique)
4369 ]
4370 interface ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemovedExtendedData1
4371 {
4372     HRESULT GetPageFaultAllocationOutput2(D3D12_DRED_PAGE_FAULT_OUTPUT2 *output);
4373     D3D12_DRED_DEVICE_STATE GetDeviceState();
4374 }
4375
4376 typedef enum D3D12_BACKGROUND_PROCESSING_MODE
4377 {
4378     D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0x0,
4379     D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = 0x1,
4380     D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = 0x2,
4381     D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = 0x3,
4382 } D3D12_BACKGROUND_PROCESSING_MODE;
4383
4384 typedef enum D3D12_MEASUREMENTS_ACTION
4385 {
4386     D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0x0,
4387     D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = 0x1,
4388     D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = 0x2,
4389     D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = 0x3,
4390 } D3D12_MEASUREMENTS_ACTION;
4391
4392 [
4393     uuid(c70b221b-40e4-4a17-89af-025a0727a6dc),
4394     object,
4395     local,
4396     pointer_default(unique)
4397 ]
4398 interface ID3D12Device6 : ID3D12Device5
4399 {
4400     HRESULT SetBackgroundProcessingMode(
4401             D3D12_BACKGROUND_PROCESSING_MODE mode,
4402             D3D12_MEASUREMENTS_ACTION action,
4403             HANDLE event,
4404             BOOL *further_measurements_desired);
4405 }
4406
4407 cpp_quote("DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED, 0x62b0084e, 0xc70e, 0x4daa, 0xa1, 0x09, 0x30, 0xff, 0x8d, 0x5a, 0x04, 0x82);")
4408
4409 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT
4410 {
4411     UINT NodeIndex;
4412     UINT Count;
4413 } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT;
4414
4415 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES
4416 {
4417     UINT NodeIndex;
4418     UINT Count;
4419     GUID *pTypes;
4420 } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES;
4421
4422 typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1
4423 {
4424     UINT NodeMask;
4425     D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
4426     GUID ProtectionType;
4427 } D3D12_PROTECTED_RESOURCE_SESSION_DESC1;
4428
4429 [
4430     uuid(d6f12dd6-76fb-406e-8961-4296eefc0409),
4431     object,
4432     local,
4433     pointer_default(unique)
4434 ]
4435 interface ID3D12ProtectedResourceSession1 : ID3D12ProtectedResourceSession
4436 {
4437     D3D12_PROTECTED_RESOURCE_SESSION_DESC1 GetDesc1();
4438 }
4439
4440 [
4441     uuid(5c014b53-68a1-4b9b-8bd1-dd6046b9358b),
4442     object,
4443     local,
4444     pointer_default(unique)
4445 ]
4446 interface ID3D12Device7 : ID3D12Device6
4447 {
4448     HRESULT AddToStateObject(
4449             const D3D12_STATE_OBJECT_DESC *addition,
4450             ID3D12StateObject *state_object_to_grow_from,
4451             REFIID riid, void **new_state_object);
4452
4453     HRESULT CreateProtectedResourceSession1(
4454             const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *desc,
4455             REFIID riid, void **session);
4456 }
4457
4458 [
4459     uuid(9218e6bb-f944-4f7e-a75c-b1b2c7b701f3),
4460     object,
4461     local,
4462     pointer_default(unique)
4463 ]
4464 interface ID3D12Device8 : ID3D12Device7
4465 {
4466     D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo2(
4467             UINT visible_mask,
4468             UINT resource_descs_count,
4469             const D3D12_RESOURCE_DESC1 *resource_descs,
4470             D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1);
4471
4472     HRESULT CreateCommittedResource2(
4473             const D3D12_HEAP_PROPERTIES *heap_properties,
4474             D3D12_HEAP_FLAGS heap_flags,
4475             const D3D12_RESOURCE_DESC1 *desc,
4476             D3D12_RESOURCE_STATES initial_resource_state,
4477             const D3D12_CLEAR_VALUE *optimized_clear_value,
4478             ID3D12ProtectedResourceSession *protected_session,
4479             REFIID riid_resource, void **resource);
4480
4481     HRESULT CreatePlacedResource1(
4482             ID3D12Heap *heap,
4483             UINT64 heap_offset,
4484             const D3D12_RESOURCE_DESC1 *desc,
4485             D3D12_RESOURCE_STATES initial_state,
4486             const D3D12_CLEAR_VALUE *optimized_clear_value,
4487             REFIID riid, void **resource);
4488
4489     void CreateSamplerFeedbackUnorderedAccessView(
4490             ID3D12Resource *targeted_resource,
4491             ID3D12Resource *feedback_resource,
4492             D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor);
4493
4494     void GetCopyableFootprints1(
4495             const D3D12_RESOURCE_DESC1 *resource_desc,
4496             UINT first_subresource,
4497             UINT subresources_count,
4498             UINT64 base_offset,
4499             D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts,
4500             UINT *rows_count,
4501             UINT64 *row_size_in_bytes,
4502             UINT64 *total_bytes);
4503 }
4504
4505 [
4506     uuid(9d5e227a-4430-4161-88b3-3eca6bb16e19),
4507     object,
4508     local,
4509     pointer_default(unique)
4510 ]
4511 interface ID3D12Resource1 : ID3D12Resource
4512 {
4513     HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session);
4514 }
4515
4516 [
4517     uuid(be36ec3b-ea85-4aeb-a45a-e9d76404a495),
4518     object,
4519     local,
4520     pointer_default(unique)
4521 ]
4522 interface ID3D12Resource2 : ID3D12Resource1
4523 {
4524     D3D12_RESOURCE_DESC1 GetDesc1();
4525 }
4526
4527 [
4528     uuid(572f7389-2168-49e3-9693-d6df5871bf6d),
4529     object,
4530     local,
4531     pointer_default(unique)
4532 ]
4533 interface ID3D12Heap1 : ID3D12Heap
4534 {
4535     HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session);
4536 }
4537
4538 typedef enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE
4539 {
4540     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0x0,
4541     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = 0x1,
4542     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = 0x2,
4543     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = 0x3,
4544 } D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE;
4545
4546 typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
4547 {
4548     D3D12_CLEAR_VALUE ClearValue;
4549 } D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS;
4550
4551 typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS
4552 {
4553     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type;
4554
4555     union
4556     {
4557         D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear;
4558     };
4559 } D3D12_RENDER_PASS_BEGINNING_ACCESS;
4560
4561 typedef enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE
4562 {
4563     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0x0,
4564     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = 0x1,
4565     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = 0x2,
4566     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = 0x3,
4567 } D3D12_RENDER_PASS_ENDING_ACCESS_TYPE;
4568
4569 typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS
4570 {
4571     UINT SrcSubresource;
4572     UINT DstSubresource;
4573     UINT DstX;
4574     UINT DstY;
4575     D3D12_RECT SrcRect;
4576 } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS;
4577
4578 typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS
4579 {
4580     ID3D12Resource *pSrcResource;
4581     ID3D12Resource *pDstResource;
4582     UINT SubresourceCount;
4583     const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters;
4584     DXGI_FORMAT Format;
4585     D3D12_RESOLVE_MODE ResolveMode;
4586     BOOL PreserveResolveSource;
4587 } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS;
4588
4589 typedef struct D3D12_RENDER_PASS_ENDING_ACCESS
4590 {
4591     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type;
4592     union
4593     {
4594         D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve;
4595     };
4596 } D3D12_RENDER_PASS_ENDING_ACCESS;
4597
4598 typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC
4599 {
4600     D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
4601     D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess;
4602     D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess;
4603 } D3D12_RENDER_PASS_RENDER_TARGET_DESC;
4604
4605 typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC
4606 {
4607     D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
4608     D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess;
4609     D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess;
4610     D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess;
4611     D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess;
4612 } D3D12_RENDER_PASS_DEPTH_STENCIL_DESC;
4613
4614 typedef enum D3D12_RENDER_PASS_FLAGS
4615 {
4616     D3D12_RENDER_PASS_FLAG_NONE = 0x0,
4617     D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1,
4618     D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2,
4619     D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4
4620 } D3D12_RENDER_PASS_FLAGS;
4621 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RENDER_PASS_FLAGS);")
4622
4623 [
4624     uuid(dbb84c27-36ce-4fc9-b801-f048c46ac570),
4625     object,
4626     local,
4627     pointer_default(unique)
4628 ]
4629 interface ID3D12MetaCommand : ID3D12Pageable
4630 {
4631     UINT64 GetRequiredParameterResourceSize(
4632             D3D12_META_COMMAND_PARAMETER_STAGE stage,
4633             UINT parameter_index);
4634 }
4635
4636 typedef struct D3D12_DISPATCH_RAYS_DESC
4637 {
4638     D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord;
4639     D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable;
4640     D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable;
4641     D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable;
4642     UINT Width;
4643     UINT Height;
4644     UINT Depth;
4645 } D3D12_DISPATCH_RAYS_DESC;
4646
4647 [
4648     uuid(8754318e-d3a9-4541-98cf-645b50dc4874),
4649     object,
4650     local,
4651     pointer_default(unique)
4652 ]
4653 interface ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandList3
4654 {
4655     void BeginRenderPass(
4656             UINT render_targets_count,
4657             const D3D12_RENDER_PASS_RENDER_TARGET_DESC *render_targets,
4658             const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *depth_stencil,
4659             D3D12_RENDER_PASS_FLAGS flags);
4660
4661     void EndRenderPass();
4662
4663     void InitializeMetaCommand(
4664             ID3D12MetaCommand *meta_command,
4665             const void *initialization_parameters_data,
4666             SIZE_T initialization_parameters_data_size_in_bytes);
4667
4668     void ExecuteMetaCommand(
4669             ID3D12MetaCommand *meta_command,
4670             const void *execution_parameters_data,
4671             SIZE_T execution_parameters_data_size_in_bytes);
4672
4673     void BuildRaytracingAccelerationStructure(
4674             const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *desc,
4675             UINT postbuild_info_descs_count,
4676             const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *postbuild_info_descs);
4677
4678     void EmitRaytracingAccelerationStructurePostbuildInfo(
4679             const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *desc,
4680             UINT src_acceleration_structures_count,
4681             const D3D12_GPU_VIRTUAL_ADDRESS *src_acceleration_structure_data);
4682
4683     void CopyRaytracingAccelerationStructure(
4684             D3D12_GPU_VIRTUAL_ADDRESS dst_acceleration_structure_data,
4685             D3D12_GPU_VIRTUAL_ADDRESS src_acceleration_structure_data,
4686             D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode);
4687
4688     void SetPipelineState1(ID3D12StateObject *state_object);
4689
4690     void DispatchRays(const D3D12_DISPATCH_RAYS_DESC *desc);
4691 }
4692
4693 typedef enum D3D12_SHADER_CACHE_MODE
4694 {
4695     D3D12_SHADER_CACHE_MODE_MEMORY = 0x0,
4696     D3D12_SHADER_CACHE_MODE_DISK = 0x1,
4697 } D3D12_SHADER_CACHE_MODE;
4698
4699 typedef enum D3D12_SHADER_CACHE_FLAGS
4700 {
4701     D3D12_SHADER_CACHE_FLAG_NONE = 0x0,
4702     D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1,
4703     D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2,
4704 } D3D12_SHADER_CACHE_FLAGS;
4705 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_FLAGS);")
4706
4707 typedef struct D3D12_SHADER_CACHE_SESSION_DESC
4708 {
4709     GUID Identifier;
4710     D3D12_SHADER_CACHE_MODE Mode;
4711     D3D12_SHADER_CACHE_FLAGS Flags;
4712
4713     UINT MaximumInMemoryCacheSizeBytes;
4714     UINT MaximumInMemoryCacheEntries;
4715
4716     UINT MaximumValueFileSizeBytes;
4717
4718     UINT64 Version;
4719 } D3D12_SHADER_CACHE_SESSION_DESC;
4720
4721 typedef enum D3D12_BARRIER_LAYOUT
4722 {
4723     D3D12_BARRIER_LAYOUT_UNDEFINED = 0xffffffff,
4724     D3D12_BARRIER_LAYOUT_COMMON = 0x0,
4725     D3D12_BARRIER_LAYOUT_PRESENT = 0x0,
4726     D3D12_BARRIER_LAYOUT_GENERIC_READ = 0x1,
4727     D3D12_BARRIER_LAYOUT_RENDER_TARGET = 0x2,
4728     D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS = 0x3,
4729     D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE = 0x4,
4730     D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ = 0x5,
4731     D3D12_BARRIER_LAYOUT_SHADER_RESOURCE = 0x6,
4732     D3D12_BARRIER_LAYOUT_COPY_SOURCE = 0x7,
4733     D3D12_BARRIER_LAYOUT_COPY_DEST = 0x8,
4734     D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE = 0x9,
4735     D3D12_BARRIER_LAYOUT_RESOLVE_DEST = 0xa,
4736     D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE = 0xb,
4737     D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ = 0xc,
4738     D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE = 0xd,
4739     D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ = 0xe,
4740     D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE = 0xf,
4741     D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ = 0x10,
4742     D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE = 0x11,
4743     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON = 0x12,
4744     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ = 0x13,
4745     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS = 0x14,
4746     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE = 0x15,
4747     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE = 0x16,
4748     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST = 0x17,
4749     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON = 0x18,
4750     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ = 0x19,
4751     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS = 0x1a,
4752     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE = 0x1b,
4753     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE = 0x1c,
4754     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST = 0x1d,
4755     D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON = 0x1e,
4756 } D3D12_BARRIER_LAYOUT;
4757
4758 typedef enum D3D12_BARRIER_SYNC
4759 {
4760     D3D12_BARRIER_SYNC_NONE = 0x0,
4761     D3D12_BARRIER_SYNC_ALL = 0x1,
4762     D3D12_BARRIER_SYNC_DRAW = 0x2,
4763     D3D12_BARRIER_SYNC_INPUT_ASSEMBLER = 0x4,
4764     D3D12_BARRIER_SYNC_VERTEX_SHADING = 0x8,
4765     D3D12_BARRIER_SYNC_PIXEL_SHADING = 0x10,
4766     D3D12_BARRIER_SYNC_DEPTH_STENCIL = 0x20,
4767     D3D12_BARRIER_SYNC_RENDER_TARGET = 0x40,
4768     D3D12_BARRIER_SYNC_COMPUTE_SHADING = 0x80,
4769     D3D12_BARRIER_SYNC_RAYTRACING = 0x100,
4770     D3D12_BARRIER_SYNC_COPY = 0x200,
4771     D3D12_BARRIER_SYNC_RESOLVE = 0x400,
4772     D3D12_BARRIER_SYNC_EXECUTE_INDIRECT = 0x800,
4773     D3D12_BARRIER_SYNC_PREDICATION = 0x800,
4774     D3D12_BARRIER_SYNC_ALL_SHADING = 0x1000,
4775     D3D12_BARRIER_SYNC_NON_PIXEL_SHADING = 0x2000,
4776     D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO = 0x4000,
4777     D3D12_BARRIER_SYNC_VIDEO_DECODE = 0x100000,
4778     D3D12_BARRIER_SYNC_VIDEO_PROCESS = 0x200000,
4779     D3D12_BARRIER_SYNC_VIDEO_ENCODE = 0x400000,
4780     D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE = 0x800000,
4781     D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE = 0x1000000,
4782     D3D12_BARRIER_SYNC_SPLIT = 0x80000000,
4783 } D3D12_BARRIER_SYNC;
4784 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_SYNC);")
4785
4786 typedef enum D3D12_BARRIER_ACCESS
4787 {
4788     D3D12_BARRIER_ACCESS_COMMON = 0,
4789     D3D12_BARRIER_ACCESS_VERTEX_BUFFER = 0x1,
4790     D3D12_BARRIER_ACCESS_CONSTANT_BUFFER = 0x2,
4791     D3D12_BARRIER_ACCESS_INDEX_BUFFER = 0x4,
4792     D3D12_BARRIER_ACCESS_RENDER_TARGET = 0x8,
4793     D3D12_BARRIER_ACCESS_UNORDERED_ACCESS = 0x10,
4794     D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE = 0x20,
4795     D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ = 0x40,
4796     D3D12_BARRIER_ACCESS_SHADER_RESOURCE = 0x80,
4797     D3D12_BARRIER_ACCESS_STREAM_OUTPUT = 0x100,
4798     D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT = 0x200,
4799     D3D12_BARRIER_ACCESS_PREDICATION = 0x200,
4800     D3D12_BARRIER_ACCESS_COPY_DEST = 0x400,
4801     D3D12_BARRIER_ACCESS_COPY_SOURCE = 0x800,
4802     D3D12_BARRIER_ACCESS_RESOLVE_DEST = 0x1000,
4803     D3D12_BARRIER_ACCESS_RESOLVE_SOURCE = 0x2000,
4804     D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ = 0x4000,
4805     D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE = 0x8000,
4806     D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE = 0x10000,
4807     D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ = 0x20000,
4808     D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE = 0x40000,
4809     D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ = 0x80000,
4810     D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE = 0x100000,
4811     D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ = 0x200000,
4812     D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE = 0x400000,
4813     D3D12_BARRIER_ACCESS_NO_ACCESS = 0x80000000,
4814 } D3D12_BARRIER_ACCESS;
4815 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_ACCESS);")
4816
4817 typedef enum D3D12_BARRIER_TYPE
4818 {
4819     D3D12_BARRIER_TYPE_GLOBAL = 0x0,
4820     D3D12_BARRIER_TYPE_TEXTURE = 0x1,
4821     D3D12_BARRIER_TYPE_BUFFER = 0x2,
4822 } D3D12_BARRIER_TYPE;
4823
4824 typedef enum D3D12_TEXTURE_BARRIER_FLAGS
4825 {
4826     D3D12_TEXTURE_BARRIER_FLAG_NONE = 0x0,
4827     D3D12_TEXTURE_BARRIER_FLAG_DISCARD = 0x1,
4828 } D3D12_TEXTURE_BARRIER_FLAGS;
4829 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TEXTURE_BARRIER_FLAGS);")
4830
4831 typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE
4832 {
4833     UINT IndexOrFirstMipLevel;
4834     UINT NumMipLevels;
4835     UINT FirstArraySlice;
4836     UINT NumArraySlices;
4837     UINT FirstPlane;
4838     UINT NumPlanes;
4839 } D3D12_BARRIER_SUBRESOURCE_RANGE;
4840
4841 typedef struct D3D12_GLOBAL_BARRIER
4842 {
4843     D3D12_BARRIER_SYNC SyncBefore;
4844     D3D12_BARRIER_SYNC SyncAfter;
4845     D3D12_BARRIER_ACCESS AccessBefore;
4846     D3D12_BARRIER_ACCESS AccessAfter;
4847 } D3D12_GLOBAL_BARRIER;
4848
4849 typedef struct D3D12_TEXTURE_BARRIER
4850 {
4851     D3D12_BARRIER_SYNC SyncBefore;
4852     D3D12_BARRIER_SYNC SyncAfter;
4853     D3D12_BARRIER_ACCESS AccessBefore;
4854     D3D12_BARRIER_ACCESS AccessAfter;
4855     D3D12_BARRIER_LAYOUT LayoutBefore;
4856     D3D12_BARRIER_LAYOUT LayoutAfter;
4857     ID3D12Resource *pResource;
4858     D3D12_BARRIER_SUBRESOURCE_RANGE Subresources;
4859     D3D12_TEXTURE_BARRIER_FLAGS Flags;
4860 } D3D12_TEXTURE_BARRIER;
4861
4862 typedef struct D3D12_BUFFER_BARRIER
4863 {
4864     D3D12_BARRIER_SYNC SyncBefore;
4865     D3D12_BARRIER_SYNC SyncAfter;
4866     D3D12_BARRIER_ACCESS AccessBefore;
4867     D3D12_BARRIER_ACCESS AccessAfter;
4868     ID3D12Resource *pResource;
4869     UINT64 Offset;
4870     UINT64 Size;
4871 } D3D12_BUFFER_BARRIER;
4872
4873 typedef struct D3D12_BARRIER_GROUP
4874 {
4875     D3D12_BARRIER_TYPE Type;
4876     UINT32 NumBarriers;
4877     union
4878     {
4879         const D3D12_GLOBAL_BARRIER *pGlobalBarriers;
4880         const D3D12_TEXTURE_BARRIER *pTextureBarriers;
4881         const D3D12_BUFFER_BARRIER *pBufferBarriers;
4882     };
4883 } D3D12_BARRIER_GROUP;
4884
4885 [
4886     uuid(28e2495d-0f64-4ae4-a6ec-129255dc49a8),
4887     object,
4888     local,
4889     pointer_default(unique)
4890 ]
4891 interface ID3D12ShaderCacheSession : ID3D12DeviceChild
4892 {
4893     HRESULT FindValue(
4894             const void *key,
4895             UINT key_size,
4896             void *value,
4897             UINT *value_size);
4898     HRESULT StoreValue(
4899             const void *key,
4900             UINT key_size,
4901             const void *value,
4902             UINT value_size);
4903
4904     void SetDeleteOnDestroy();
4905     D3D12_SHADER_CACHE_SESSION_DESC GetDesc();
4906 }
4907
4908 typedef enum D3D12_SHADER_CACHE_KIND_FLAGS
4909 {
4910     D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1,
4911     D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2,
4912     D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4,
4913     D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8,
4914 } D3D12_SHADER_CACHE_KIND_FLAGS;
4915 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_KIND_FLAGS);")
4916
4917 typedef enum D3D12_SHADER_CACHE_CONTROL_FLAGS
4918 {
4919     D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1,
4920     D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2,
4921     D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4,
4922 } D3D12_SHADER_CACHE_CONTROL_FLAGS;
4923 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_CONTROL_FLAGS);")
4924
4925 [
4926     uuid(4c80e962-f032-4f60-bc9e-ebc2cfa1d83c),
4927     object,
4928     local,
4929     pointer_default(unique)
4930 ]
4931 interface ID3D12Device9 : ID3D12Device8
4932 {
4933     HRESULT CreateShaderCacheSession(
4934             const D3D12_SHADER_CACHE_SESSION_DESC *desc,
4935             REFIID riid, void **session);
4936
4937     HRESULT ShaderCacheControl(
4938             D3D12_SHADER_CACHE_KIND_FLAGS kinds,
4939             D3D12_SHADER_CACHE_CONTROL_FLAGS control);
4940
4941     HRESULT CreateCommandQueue1(
4942             const D3D12_COMMAND_QUEUE_DESC *desc,
4943             REFIID creator_id,
4944             REFIID riid,
4945             void **command_queue);
4946 }
4947
4948 [
4949     uuid(517f8718-aa66-49f9-b02b-a7ab89c06031),
4950     object,
4951     local,
4952     pointer_default(unique)
4953 ]
4954 interface ID3D12Device10 : ID3D12Device9
4955 {
4956     HRESULT CreateCommittedResource3(
4957             const D3D12_HEAP_PROPERTIES *heap_properties,
4958             D3D12_HEAP_FLAGS heap_flags,
4959             const D3D12_RESOURCE_DESC1 *desc,
4960             D3D12_BARRIER_LAYOUT initial_layout,
4961             const D3D12_CLEAR_VALUE *optimized_clear_value,
4962             ID3D12ProtectedResourceSession *protected_session,
4963             UINT32 castable_formats_count,
4964             DXGI_FORMAT *castable_formats,
4965             REFIID riid_resource,
4966             void **resource);
4967
4968     HRESULT CreatePlacedResource2(
4969             ID3D12Heap *heap,
4970             UINT64 heap_offset,
4971             const D3D12_RESOURCE_DESC1 *desc,
4972             D3D12_BARRIER_LAYOUT initial_layout,
4973             const D3D12_CLEAR_VALUE *optimized_clear_value,
4974             UINT32 castable_formats_count,
4975             DXGI_FORMAT *castable_formats,
4976             REFIID riid,
4977             void **resource);
4978
4979     HRESULT CreateReservedResource2(
4980             const D3D12_RESOURCE_DESC *desc,
4981             D3D12_BARRIER_LAYOUT initial_layout,
4982             const D3D12_CLEAR_VALUE *optimized_clear_value,
4983             ID3D12ProtectedResourceSession *protected_session,
4984             UINT32 castable_formats_count,
4985             DXGI_FORMAT *castable_formats,
4986             REFIID riid,
4987             void **resource);
4988 }
4989
4990 [
4991     uuid(bc66d368-7373-4943-8757-fc87dc79e476),
4992     object,
4993     local,
4994     pointer_default(unique)
4995 ]
4996 interface ID3D12VirtualizationGuestDevice : IUnknown
4997 {
4998     HRESULT ShareWithHost(
4999             ID3D12DeviceChild *object,
5000             HANDLE *handle);
5001
5002     HRESULT CreateFenceFd(
5003             ID3D12Fence *fence,
5004             UINT64 fence_value,
5005             int *fence_fd);
5006 }
5007
5008 [
5009     uuid(7071e1f0-e84b-4b33-974f-12fa49de65c5),
5010     object,
5011     local,
5012     pointer_default(unique)
5013 ]
5014 interface ID3D12Tools : IUnknown
5015 {
5016     void EnableShaderInstrumentation(BOOL enable);
5017     BOOL ShaderInstrumentationEnabled();
5018 }
5019
5020 cpp_quote("DEFINE_GUID(CLSID_D3D12Debug,                     0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f);")
5021 cpp_quote("DEFINE_GUID(CLSID_D3D12Tools,                     0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8);")
5022 cpp_quote("DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2);")
5023 cpp_quote("DEFINE_GUID(CLSID_D3D12SDKConfiguration,          0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce);")
5024
5025 [
5026     uuid(e9eb5314-33aa-42b2-a718-d77f58b1f1c7),
5027     object,
5028     local,
5029     pointer_default(unique)
5030 ]
5031 interface ID3D12SDKConfiguration : IUnknown
5032 {
5033     HRESULT SetSDKVersion(UINT version, const char *path);
5034 }
5035
5036 typedef enum D3D12_AXIS_SHADING_RATE
5037 {
5038     D3D12_AXIS_SHADING_RATE_1X = 0x0,
5039     D3D12_AXIS_SHADING_RATE_2X = 0x1,
5040     D3D12_AXIS_SHADING_RATE_4X = 0x2,
5041 } D3D12_AXIS_SHADING_RATE;
5042
5043 typedef enum D3D12_SHADING_RATE
5044 {
5045     D3D12_SHADING_RATE_1X1 = 0x0,
5046     D3D12_SHADING_RATE_1X2 = 0x1,
5047     D3D12_SHADING_RATE_2X1 = 0x4,
5048     D3D12_SHADING_RATE_2X2 = 0x5,
5049     D3D12_SHADING_RATE_2X4 = 0x6,
5050     D3D12_SHADING_RATE_4X2 = 0x9,
5051     D3D12_SHADING_RATE_4X4 = 0xa,
5052 } D3D12_SHADING_RATE;
5053
5054 typedef enum D3D12_SHADING_RATE_COMBINER
5055 {
5056     D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0x0,
5057     D3D12_SHADING_RATE_COMBINER_OVERRIDE = 0x1,
5058     D3D12_SHADING_RATE_COMBINER_MIN = 0x2,
5059     D3D12_SHADING_RATE_COMBINER_MAX = 0x3,
5060     D3D12_SHADING_RATE_COMBINER_SUM = 0x4,
5061 } D3D12_SHADING_RATE_COMBINER;
5062
5063 [
5064     uuid(55050859-4024-474c-87f5-6472eaee44ea),
5065     object,
5066     local,
5067     pointer_default(unique)
5068 ]
5069 interface ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandList4
5070 {
5071     void RSSetShadingRate(
5072             D3D12_SHADING_RATE base_shading_rate,
5073             const D3D12_SHADING_RATE_COMBINER *combiners);
5074
5075     void RSSetShadingRateImage(
5076             ID3D12Resource *shading_rate_image);
5077 }
5078
5079 const UINT D3D12_SHADING_RATE_X_AXIS_SHIFT = 2;
5080 const UINT D3D12_SHADING_RATE_VALID_MASK = 3;
5081
5082 cpp_quote("#define D3D12_MAKE_COARSE_SHADING_RATE(x, y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y))")
5083 cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(val) (((val) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK)")
5084 cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(val) ((val) & D3D12_SHADING_RATE_VALID_MASK)")
5085
5086 typedef struct D3D12_DISPATCH_MESH_ARGUMENTS
5087 {
5088     UINT ThreadGroupCountX;
5089     UINT ThreadGroupCountY;
5090     UINT ThreadGroupCountZ;
5091 } D3D12_DISPATCH_MESH_ARGUMENTS;
5092
5093 [
5094     uuid(c3827890-e548-4cfa-96cf-5689a9370f80),
5095     object,
5096     local,
5097     pointer_default(unique)
5098 ]
5099 interface ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandList5
5100 {
5101     void DispatchMesh(
5102             UINT thread_group_count_x,
5103             UINT thread_group_count_y,
5104             UINT thread_group_count_z);
5105 }
5106
5107 [
5108     uuid(dd171223-8b61-4769-90e3-160ccde4e2c1),
5109     object,
5110     local,
5111     pointer_default(unique)
5112 ]
5113 interface ID3D12GraphicsCommandList7 : ID3D12GraphicsCommandList6
5114 {
5115     void Barrier(
5116             UINT32 barrier_groups_count,
5117             const D3D12_BARRIER_GROUP *barrier_groups);
5118 };
5119
5120 cpp_quote("#ifndef D3D12_IGNORE_SDK_LAYERS")
5121 cpp_quote("#include \"d3d12sdklayers.h\"")
5122 cpp_quote("#endif")
5123
5124 typedef HRESULT (__stdcall *PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)(
5125         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5126
5127 [local] HRESULT __stdcall D3D12CreateRootSignatureDeserializer(
5128         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5129
5130 typedef HRESULT (__stdcall *PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)(
5131         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5132
5133 [local] HRESULT __stdcall D3D12CreateVersionedRootSignatureDeserializer(
5134         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5135
5136 typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)(
5137         const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
5138         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
5139
5140 [local] HRESULT __stdcall D3D12SerializeRootSignature(
5141         const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
5142         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
5143
5144 typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)(
5145         const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob);
5146
5147 [local] HRESULT __stdcall D3D12SerializeVersionedRootSignature(
5148         const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *root_signature_desc,
5149         ID3DBlob **blob, ID3DBlob **error_blob);
5150
5151 typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter,
5152         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
5153
5154 [local] HRESULT __stdcall D3D12CreateDevice(IUnknown *adapter,
5155         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
5156
5157 typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug);
5158
5159 [local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug);
5160
5161 [local] HRESULT __stdcall D3D12EnableExperimentalFeatures(UINT feature_count,
5162         const IID *iids, void *configurations, UINT *configurations_sizes);
5163
5164 cpp_quote("static const UUID D3D12ExperimentalShaderModels = { 0x76f5573e, 0xf13a, 0x40f5, { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } };")
5165 cpp_quote("static const UUID D3D12TiledResourceTier4 = { 0xc9c4725f, 0xa81a, 0x4f56, { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } };")
5166 cpp_quote("static const UUID D3D12MetaCommand = { 0xc734c97e, 0x8077, 0x48c8, { 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77 } };")
5167
5168 typedef HRESULT (__stdcall *PFN_D3D12_GET_INTERFACE)(REFCLSID clsid, REFIID iid, void **debug);
5169
5170 [local] HRESULT __stdcall D3D12GetInterface(REFCLSID clsid, REFIID iid, void **debug);