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 enum D3D12_FEATURE
2450 {
2451     D3D12_FEATURE_D3D12_OPTIONS = 0,
2452     D3D12_FEATURE_ARCHITECTURE = 1,
2453     D3D12_FEATURE_FEATURE_LEVELS = 2,
2454     D3D12_FEATURE_FORMAT_SUPPORT = 3,
2455     D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4,
2456     D3D12_FEATURE_FORMAT_INFO = 5,
2457     D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
2458     D3D12_FEATURE_SHADER_MODEL = 7,
2459     D3D12_FEATURE_D3D12_OPTIONS1 = 8,
2460     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT = 10,
2461     D3D12_FEATURE_ROOT_SIGNATURE = 12,
2462     D3D12_FEATURE_ARCHITECTURE1 = 16,
2463     D3D12_FEATURE_D3D12_OPTIONS2 = 18,
2464     D3D12_FEATURE_SHADER_CACHE = 19,
2465     D3D12_FEATURE_COMMAND_QUEUE_PRIORITY = 20,
2466     D3D12_FEATURE_D3D12_OPTIONS3 = 21,
2467     D3D12_FEATURE_EXISTING_HEAPS = 22,
2468     D3D12_FEATURE_D3D12_OPTIONS4 = 23,
2469     D3D12_FEATURE_SERIALIZATION = 24,
2470     D3D12_FEATURE_CROSS_NODE = 25,
2471     D3D12_FEATURE_D3D12_OPTIONS5 = 27,
2472     D3D12_FEATURE_DISPLAYABLE = 28,
2473     D3D12_FEATURE_D3D12_OPTIONS6 = 30,
2474     D3D12_FEATURE_QUERY_META_COMMAND = 31,
2475     D3D12_FEATURE_D3D12_OPTIONS7 = 32,
2476     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33,
2477     D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES = 34,
2478     D3D12_FEATURE_D3D12_OPTIONS8 = 36,
2479     D3D12_FEATURE_D3D12_OPTIONS9 = 37,
2480     D3D12_FEATURE_D3D12_OPTIONS10 = 39,
2481     D3D12_FEATURE_D3D12_OPTIONS11 = 40,
2482     D3D12_FEATURE_D3D12_OPTIONS12 = 41,
2483     D3D12_FEATURE_D3D12_OPTIONS13 = 42,
2484 } D3D12_FEATURE;
2485
2486 typedef struct D3D12_MEMCPY_DEST
2487 {
2488     void *pData;
2489     SIZE_T RowPitch;
2490     SIZE_T SlicePitch;
2491 } D3D12_MEMCPY_DEST;
2492
2493 typedef struct D3D12_SUBRESOURCE_DATA
2494 {
2495     const void *pData;
2496     LONG_PTR RowPitch;
2497     LONG_PTR SlicePitch;
2498 } D3D12_SUBRESOURCE_DATA;
2499
2500 typedef enum D3D12_MULTIPLE_FENCE_WAIT_FLAGS
2501 {
2502     D3D12_MULTIPLE_FENCE_WAIT_FLAG_NONE = 0x0,
2503     D3D12_MULTIPLE_FENCE_WAIT_FLAG_ANY = 0x1,
2504     D3D12_MULTIPLE_FENCE_WAIT_FLAG_ALL = 0x0,
2505 } D3D12_MULTIPLE_FENCE_WAIT_FLAGS;
2506 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_MULTIPLE_FENCE_WAIT_FLAGS);")
2507
2508 typedef enum D3D12_RESIDENCY_PRIORITY
2509 {
2510     D3D12_RESIDENCY_PRIORITY_MINIMUM = 0x28000000,
2511     D3D12_RESIDENCY_PRIORITY_LOW = 0x50000000,
2512     D3D12_RESIDENCY_PRIORITY_NORMAL = 0x78000000,
2513     D3D12_RESIDENCY_PRIORITY_HIGH = 0xa0010000,
2514     D3D12_RESIDENCY_PRIORITY_MAXIMUM = 0xc8000000,
2515 } D3D12_RESIDENCY_PRIORITY;
2516
2517 typedef struct D3D12_WRITEBUFFERIMMEDIATE_PARAMETER
2518 {
2519     D3D12_GPU_VIRTUAL_ADDRESS Dest;
2520     UINT32 Value;
2521 } D3D12_WRITEBUFFERIMMEDIATE_PARAMETER;
2522
2523 typedef enum D3D12_PROTECTED_RESOURCE_SESSION_FLAGS
2524 {
2525     D3D12_PROTECTED_RESOURCE_SESSION_FLAG_NONE = 0,
2526 } D3D12_PROTECTED_RESOURCE_SESSION_FLAGS;
2527 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_FLAGS);")
2528
2529 typedef enum D3D12_PROTECTED_SESSION_STATUS
2530 {
2531     D3D12_PROTECTED_SESSION_STATUS_OK = 0,
2532     D3D12_PROTECTED_SESSION_STATUS_INVALID = 1,
2533 } D3D12_PROTECTED_SESSION_STATUS;
2534
2535 typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC
2536 {
2537     UINT NodeMask;
2538     D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
2539 } D3D12_PROTECTED_RESOURCE_SESSION_DESC;
2540
2541 [
2542     uuid(c4fec28f-7966-4e95-9f94-f431cb56c3b8),
2543     object,
2544     local,
2545     pointer_default(unique)
2546 ]
2547 interface ID3D12Object : IUnknown
2548 {
2549     HRESULT GetPrivateData(REFGUID guid, UINT *data_size, void *data);
2550     HRESULT SetPrivateData(REFGUID guid, UINT data_size, const void *data);
2551     HRESULT SetPrivateDataInterface(REFGUID guid, const IUnknown *data);
2552     HRESULT SetName(const WCHAR *name);
2553 }
2554
2555 [
2556     uuid(905db94b-a00c-4140-9df5-2b64ca9ea357),
2557     object,
2558     local,
2559     pointer_default(unique)
2560 ]
2561 interface ID3D12DeviceChild : ID3D12Object
2562 {
2563     HRESULT GetDevice(REFIID riid, void **device);
2564 }
2565
2566 [
2567     uuid(63ee58fb-1268-4835-86da-f008ce62f0d6),
2568     object,
2569     local,
2570     pointer_default(unique)
2571 ]
2572 interface ID3D12Pageable : ID3D12DeviceChild
2573 {
2574 }
2575
2576 [
2577     uuid(6b3b2502-6e51-45b3-90ee-9884265e8df3),
2578     object,
2579     local,
2580     pointer_default(unique)
2581 ]
2582 interface ID3D12Heap : ID3D12Pageable
2583 {
2584     D3D12_HEAP_DESC GetDesc();
2585 }
2586
2587 [
2588     uuid(696442be-a72e-4059-bc79-5b5c98040fad),
2589     object,
2590     local,
2591     pointer_default(unique)
2592 ]
2593 interface ID3D12Resource : ID3D12Pageable
2594 {
2595     HRESULT Map(UINT sub_resource, const D3D12_RANGE *read_range, void **data);
2596     void Unmap(UINT sub_resource, const D3D12_RANGE *written_range);
2597
2598     D3D12_RESOURCE_DESC GetDesc();
2599
2600     D3D12_GPU_VIRTUAL_ADDRESS GetGPUVirtualAddress();
2601
2602     HRESULT WriteToSubresource(UINT dst_sub_resource, const D3D12_BOX *dst_box,
2603             const void *src_data, UINT src_row_pitch, UINT src_slice_pitch);
2604     HRESULT ReadFromSubresource(void *dst_data, UINT dst_row_pitch, UINT dst_slice_pitch,
2605             UINT src_sub_resource, const D3D12_BOX *src_box);
2606
2607     HRESULT GetHeapProperties(D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS *flags);
2608 }
2609
2610 [
2611     uuid(7116d91c-e7e4-47ce-b8c6-ec8168f437e5),
2612     object,
2613     local,
2614     pointer_default(unique)
2615 ]
2616 interface ID3D12CommandList : ID3D12DeviceChild
2617 {
2618     D3D12_COMMAND_LIST_TYPE GetType();
2619 }
2620
2621 typedef enum D3D12_TILE_COPY_FLAGS
2622 {
2623     D3D12_TILE_COPY_FLAG_NONE = 0x0,
2624     D3D12_TILE_COPY_FLAG_NO_HAZARD = 0x1,
2625     D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2,
2626     D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4,
2627 } D3D12_TILE_COPY_FLAGS;
2628 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_COPY_FLAGS);")
2629
2630 typedef struct D3D12_INDEX_BUFFER_VIEW
2631 {
2632     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
2633     UINT SizeInBytes;
2634     DXGI_FORMAT Format;
2635 } D3D12_INDEX_BUFFER_VIEW;
2636
2637 typedef struct D3D12_VERTEX_BUFFER_VIEW
2638 {
2639     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
2640     UINT SizeInBytes;
2641     UINT StrideInBytes;
2642 } D3D12_VERTEX_BUFFER_VIEW;
2643
2644 typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW
2645 {
2646     D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
2647     UINT64 SizeInBytes;
2648     D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation;
2649 } D3D12_STREAM_OUTPUT_BUFFER_VIEW;
2650
2651 typedef enum D3D12_CLEAR_FLAGS
2652 {
2653     D3D12_CLEAR_FLAG_DEPTH = 0x1,
2654     D3D12_CLEAR_FLAG_STENCIL = 0x2,
2655 } D3D12_CLEAR_FLAGS;
2656 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_CLEAR_FLAGS);")
2657
2658 typedef struct D3D12_DISCARD_REGION
2659 {
2660     UINT NumRects;
2661     const D3D12_RECT *pRects;
2662     UINT FirstSubresource;
2663     UINT NumSubresources;
2664 } D3D12_DISCARD_REGION;
2665
2666 typedef enum D3D12_QUERY_TYPE
2667 {
2668     D3D12_QUERY_TYPE_OCCLUSION = 0,
2669     D3D12_QUERY_TYPE_BINARY_OCCLUSION = 1,
2670     D3D12_QUERY_TYPE_TIMESTAMP = 2,
2671     D3D12_QUERY_TYPE_PIPELINE_STATISTICS = 3,
2672     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = 4,
2673     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5,
2674     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6,
2675     D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7,
2676     D3D12_QUERY_TYPE_VIDEO_DECODE_STATISTICS = 8,
2677     D3D12_QUERY_TYPE_PIPELINE_STATISTICS1 = 10,
2678 } D3D12_QUERY_TYPE;
2679
2680 typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS
2681 {
2682     UINT64 IAVertices;
2683     UINT64 IAPrimitives;
2684     UINT64 VSInvocations;
2685     UINT64 GSInvocations;
2686     UINT64 GSPrimitives;
2687     UINT64 CInvocations;
2688     UINT64 CPrimitives;
2689     UINT64 PSInvocations;
2690     UINT64 HSInvocations;
2691     UINT64 DSInvocations;
2692     UINT64 CSInvocations;
2693 } D3D12_QUERY_DATA_PIPELINE_STATISTICS;
2694
2695 typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS1
2696 {
2697     UINT64 IAVertices;
2698     UINT64 IAPrimitives;
2699     UINT64 VSInvocations;
2700     UINT64 GSInvocations;
2701     UINT64 GSPrimitives;
2702     UINT64 CInvocations;
2703     UINT64 CPrimitives;
2704     UINT64 PSInvocations;
2705     UINT64 HSInvocations;
2706     UINT64 DSInvocations;
2707     UINT64 CSInvocations;
2708     UINT64 ASInvocations;
2709     UINT64 MSInvocations;
2710     UINT64 MSPrimitives;
2711 } D3D12_QUERY_DATA_PIPELINE_STATISTICS1;
2712
2713 typedef struct D3D12_QUERY_DATA_SO_STATISTICS
2714 {
2715     UINT64 NumPrimitivesWritten;
2716     UINT64 PrimitivesStorageNeeded;
2717 } D3D12_QUERY_DATA_SO_STATISTICS;
2718
2719 typedef enum D3D12_PREDICATION_OP
2720 {
2721     D3D12_PREDICATION_OP_EQUAL_ZERO = 0,
2722     D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = 1,
2723 } D3D12_PREDICATION_OP;
2724
2725 [
2726     uuid(8efb471d-616c-4f49-90f7-127bb763fa51),
2727     object,
2728     local,
2729     pointer_default(unique)
2730 ]
2731 interface ID3D12DescriptorHeap : ID3D12Pageable
2732 {
2733     D3D12_DESCRIPTOR_HEAP_DESC GetDesc();
2734
2735     D3D12_CPU_DESCRIPTOR_HANDLE GetCPUDescriptorHandleForHeapStart();
2736     D3D12_GPU_DESCRIPTOR_HANDLE GetGPUDescriptorHandleForHeapStart();
2737 }
2738
2739 [
2740     uuid(0d9658ae-ed45-469e-a61d-970ec583cab4),
2741     object,
2742     local,
2743     pointer_default(unique)
2744 ]
2745 interface ID3D12QueryHeap : ID3D12Pageable
2746 {
2747 }
2748
2749 [
2750     uuid(c36a797c-ec80-4f0a-8985-a7b2475082d1),
2751     object,
2752     local,
2753     pointer_default(unique)
2754 ]
2755 interface ID3D12CommandSignature : ID3D12Pageable
2756 {
2757 }
2758
2759 [
2760     uuid(5b160d0f-ac1b-4185-8ba8-b3ae42a5a455),
2761     object,
2762     local,
2763     pointer_default(unique)
2764 ]
2765 interface ID3D12GraphicsCommandList : ID3D12CommandList
2766 {
2767     HRESULT Close();
2768
2769     HRESULT Reset(ID3D12CommandAllocator *allocator, ID3D12PipelineState *initial_state);
2770
2771     void ClearState(ID3D12PipelineState *pipeline_state);
2772
2773     void DrawInstanced(UINT vertex_count_per_instance, UINT instance_count,
2774             UINT start_vertex_location, UINT start_instance_location);
2775     void DrawIndexedInstanced(UINT index_count_per_instance, UINT instance_count,
2776             UINT start_vertex_location, INT base_vertex_location, UINT start_instance_location);
2777
2778     void Dispatch(UINT x, UINT u, UINT z);
2779
2780     void CopyBufferRegion(ID3D12Resource *dst_buffer, UINT64 dst_offset,
2781             ID3D12Resource *src_buffer, UINT64 src_offset, UINT64 byte_count);
2782     void CopyTextureRegion(const D3D12_TEXTURE_COPY_LOCATION *dst,
2783             UINT dst_x, UINT dst_y, UINT dst_z,
2784             const D3D12_TEXTURE_COPY_LOCATION *src, const D3D12_BOX *src_box);
2785     void CopyResource(ID3D12Resource *dst_resource, ID3D12Resource *src_resource);
2786
2787     void CopyTiles(ID3D12Resource *tiled_resource,
2788             const D3D12_TILED_RESOURCE_COORDINATE *tile_region_start_coordinate,
2789             const D3D12_TILE_REGION_SIZE *tile_region_size,
2790             ID3D12Resource *buffer,
2791             UINT64 buffer_offset,
2792             D3D12_TILE_COPY_FLAGS flags);
2793
2794     void ResolveSubresource(ID3D12Resource *dst_resource, UINT dst_sub_resource,
2795             ID3D12Resource *src_resource, UINT src_sub_resource,
2796             DXGI_FORMAT format);
2797
2798     void IASetPrimitiveTopology(D3D12_PRIMITIVE_TOPOLOGY primitive_topology);
2799
2800     void RSSetViewports(UINT viewport_count, const D3D12_VIEWPORT *viewports);
2801     void RSSetScissorRects(UINT rect_count, const D3D12_RECT *rects);
2802
2803     void OMSetBlendFactor(const FLOAT blend_factor[4]);
2804     void OMSetStencilRef(UINT stencil_ref);
2805
2806     void SetPipelineState(ID3D12PipelineState *pipeline_state);
2807
2808     void ResourceBarrier(UINT barrier_count, const D3D12_RESOURCE_BARRIER *barriers);
2809
2810     void ExecuteBundle(ID3D12GraphicsCommandList *command_list);
2811
2812     void SetDescriptorHeaps(UINT heap_count, ID3D12DescriptorHeap * const *heaps);
2813
2814     void SetComputeRootSignature(ID3D12RootSignature *root_signature);
2815     void SetGraphicsRootSignature(ID3D12RootSignature *root_signature);
2816
2817     void SetComputeRootDescriptorTable(UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor);
2818     void SetGraphicsRootDescriptorTable(UINT root_parameter_index, D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor);
2819
2820     void SetComputeRoot32BitConstant(UINT root_parameter_index, UINT data, UINT dst_offset);
2821     void SetGraphicsRoot32BitConstant(UINT root_parameter_index, UINT data, UINT dst_offset);
2822
2823     void SetComputeRoot32BitConstants(UINT root_parameter_index, UINT constant_count, const void *data,
2824             UINT dst_offset);
2825     void SetGraphicsRoot32BitConstants(UINT root_parameter_index, UINT constant_count, const void *data,
2826             UINT dst_offset);
2827
2828     void SetComputeRootConstantBufferView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2829     void SetGraphicsRootConstantBufferView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2830
2831     void SetComputeRootShaderResourceView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2832     void SetGraphicsRootShaderResourceView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2833
2834     void SetComputeRootUnorderedAccessView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2835     void SetGraphicsRootUnorderedAccessView(UINT root_parameter_index, D3D12_GPU_VIRTUAL_ADDRESS address);
2836
2837     void IASetIndexBuffer(const D3D12_INDEX_BUFFER_VIEW *view);
2838     void IASetVertexBuffers(UINT start_slot, UINT view_count, const D3D12_VERTEX_BUFFER_VIEW *views);
2839
2840     void SOSetTargets(UINT start_slot, UINT view_count, const D3D12_STREAM_OUTPUT_BUFFER_VIEW *views);
2841
2842     void OMSetRenderTargets(UINT render_target_descriptor_count,
2843             const D3D12_CPU_DESCRIPTOR_HANDLE *render_target_descriptors,
2844             BOOL single_descriptor_handle,
2845             const D3D12_CPU_DESCRIPTOR_HANDLE *depth_stencil_descriptor);
2846
2847     void ClearDepthStencilView(D3D12_CPU_DESCRIPTOR_HANDLE dsv, D3D12_CLEAR_FLAGS flags,
2848             FLOAT depth, UINT8 stencil, UINT rect_count, const D3D12_RECT *rects);
2849     void ClearRenderTargetView(D3D12_CPU_DESCRIPTOR_HANDLE rtv, const FLOAT color[4],
2850             UINT rect_count, const D3D12_RECT *rects);
2851     void ClearUnorderedAccessViewUint(D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle,
2852             D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, const UINT values[4],
2853             UINT rect_count, const D3D12_RECT *rects);
2854     void ClearUnorderedAccessViewFloat(D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle,
2855             D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle, ID3D12Resource *resource, const float values[4],
2856             UINT rect_count, const D3D12_RECT *rects);
2857
2858     void DiscardResource(ID3D12Resource *resource, const D3D12_DISCARD_REGION *region);
2859
2860     void BeginQuery(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index);
2861     void EndQuery(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type, UINT index);
2862     void ResolveQueryData(ID3D12QueryHeap *heap, D3D12_QUERY_TYPE type,
2863             UINT start_index, UINT query_count,
2864             ID3D12Resource *dst_buffer, UINT64 aligned_dst_buffer_offset);
2865
2866     void SetPredication(ID3D12Resource *buffer, UINT64 aligned_buffer_offset,
2867             D3D12_PREDICATION_OP operation);
2868
2869     void SetMarker(UINT metadata, const void *data, UINT size);
2870     void BeginEvent(UINT metadata, const void *data, UINT size);
2871     void EndEvent();
2872
2873     void ExecuteIndirect(ID3D12CommandSignature *command_signature,
2874             UINT max_command_count, ID3D12Resource *arg_buffer, UINT64 arg_buffer_offset,
2875             ID3D12Resource *count_buffer, UINT64 count_buffer_offset);
2876 }
2877
2878 [
2879     uuid(553103fb-1fe7-4557-bb38-946d7d0e7ca7),
2880     object,
2881     local,
2882     pointer_default(unique)
2883 ]
2884 interface ID3D12GraphicsCommandList1 : ID3D12GraphicsCommandList
2885 {
2886     void AtomicCopyBufferUINT(ID3D12Resource *dst_buffer, UINT64 dst_offset,
2887             ID3D12Resource *src_buffer, UINT64 src_offset,
2888             UINT dependent_resource_count, ID3D12Resource * const *dependent_resources,
2889             const D3D12_SUBRESOURCE_RANGE_UINT64 *dependent_sub_resource_ranges);
2890
2891     void AtomicCopyBufferUINT64(ID3D12Resource *dst_buffer, UINT64 dst_offset,
2892             ID3D12Resource *src_buffer, UINT64 src_offset,
2893             UINT dependent_resource_count, ID3D12Resource * const *dependent_resources,
2894             const D3D12_SUBRESOURCE_RANGE_UINT64 *dependent_sub_resource_ranges);
2895
2896     void OMSetDepthBounds(FLOAT min, FLOAT max);
2897
2898     void SetSamplePositions(UINT sample_count, UINT pixel_count,
2899             D3D12_SAMPLE_POSITION *sample_positions);
2900
2901     void ResolveSubresourceRegion(ID3D12Resource *dst_resource,
2902             UINT dst_sub_resource_idx, UINT dst_x, UINT dst_y,
2903             ID3D12Resource *src_resource, UINT src_sub_resource_idx,
2904             D3D12_RECT *src_rect, DXGI_FORMAT format, D3D12_RESOLVE_MODE mode);
2905
2906     void SetViewInstanceMask(UINT mask);
2907 }
2908
2909 [
2910     uuid(38c3e585-ff17-412c-9150-4fc6f9d72a28),
2911     object,
2912     local,
2913     pointer_default(unique)
2914 ]
2915 interface ID3D12GraphicsCommandList2 : ID3D12GraphicsCommandList1
2916 {
2917     void WriteBufferImmediate(UINT count,
2918             const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *parameters,
2919             const D3D12_WRITEBUFFERIMMEDIATE_MODE *modes);
2920 }
2921
2922 [
2923     uuid(a1533d18-0ac1-4084-85b9-89a96116806b),
2924     object,
2925     local,
2926     pointer_default(unique)
2927 ]
2928 interface ID3D12ProtectedSession : ID3D12DeviceChild
2929 {
2930     HRESULT GetStatusFence(REFIID riid, void **fence);
2931
2932     D3D12_PROTECTED_SESSION_STATUS GetSessionStatus();
2933 }
2934
2935 typedef enum D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS
2936 {
2937     D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE = 0x0,
2938     D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_SUPPORTED = 0x1,
2939 } D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS;
2940 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS);")
2941
2942 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT
2943 {
2944     UINT NodeIndex;
2945     D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS Support;
2946 } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT;
2947
2948 [
2949     uuid(6cd696f4-f289-40cc-8091-5a6c0a099c3d),
2950     object,
2951     local,
2952     pointer_default(unique)
2953 ]
2954 interface ID3D12ProtectedResourceSession : ID3D12ProtectedSession
2955 {
2956     D3D12_PROTECTED_RESOURCE_SESSION_DESC GetDesc();
2957 }
2958
2959 [
2960     uuid(6fda83a7-b84c-4e38-9ac8-c7bd22016b3d),
2961     object,
2962     local,
2963     pointer_default(unique)
2964 ]
2965 interface ID3D12GraphicsCommandList3 : ID3D12GraphicsCommandList2
2966 {
2967     void SetProtectedResourceSession(ID3D12ProtectedResourceSession *protected_resource_session);
2968 }
2969
2970 typedef enum D3D12_TILE_RANGE_FLAGS
2971 {
2972     D3D12_TILE_RANGE_FLAG_NONE = 0x0,
2973     D3D12_TILE_RANGE_FLAG_NULL = 0x1,
2974     D3D12_TILE_RANGE_FLAG_SKIP = 0x2,
2975     D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 0x4
2976 } D3D12_TILE_RANGE_FLAGS;
2977
2978 typedef enum D3D12_TILE_MAPPING_FLAGS
2979 {
2980     D3D12_TILE_MAPPING_FLAG_NONE = 0x0,
2981     D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1,
2982 } D3D12_TILE_MAPPING_FLAGS;
2983 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TILE_MAPPING_FLAGS);")
2984
2985 [
2986     uuid(0ec870a6-5d7e-4c22-8cfc-5baae07616ed),
2987     object,
2988     local,
2989     pointer_default(unique)
2990 ]
2991 interface ID3D12CommandQueue : ID3D12Pageable
2992 {
2993     void UpdateTileMappings(ID3D12Resource *resource, UINT region_count,
2994             const D3D12_TILED_RESOURCE_COORDINATE *region_start_coordinates,
2995             const D3D12_TILE_REGION_SIZE *region_sizes,
2996             ID3D12Heap *heap,
2997             UINT range_count,
2998             const D3D12_TILE_RANGE_FLAGS *range_flags,
2999             const UINT *heap_range_offsets,
3000             const UINT *range_tile_counts,
3001             D3D12_TILE_MAPPING_FLAGS flags);
3002
3003     void CopyTileMappings(ID3D12Resource *dst_resource,
3004             const D3D12_TILED_RESOURCE_COORDINATE *dst_region_start_coordinate,
3005             ID3D12Resource *src_resource,
3006             const D3D12_TILED_RESOURCE_COORDINATE *src_region_start_coordinate,
3007             const D3D12_TILE_REGION_SIZE *region_size,
3008             D3D12_TILE_MAPPING_FLAGS flags);
3009
3010     void ExecuteCommandLists(UINT command_list_count,
3011             ID3D12CommandList * const * command_lists);
3012
3013     void SetMarker(UINT metadata, const void *data, UINT size);
3014     void BeginEvent(UINT metadata, const void *data, UINT size);
3015     void EndEvent();
3016
3017     HRESULT Signal(ID3D12Fence *fence, UINT64 value);
3018     HRESULT Wait(ID3D12Fence *fence, UINT64 value);
3019
3020     HRESULT GetTimestampFrequency(UINT64 *frequency);
3021     HRESULT GetClockCalibration(UINT64 *gpu_timestamp, UINT64 *cpu_timestamp);
3022
3023     D3D12_COMMAND_QUEUE_DESC GetDesc();
3024 }
3025
3026 typedef enum D3D12_FENCE_FLAGS
3027 {
3028     D3D12_FENCE_FLAG_NONE = 0x0,
3029     D3D12_FENCE_FLAG_SHARED = 0x1,
3030     D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2,
3031     D3D12_FENCE_FLAG_NON_MONITORED = 0x4,
3032 } D3D12_FENCE_FLAGS;
3033 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_FENCE_FLAGS);")
3034
3035 typedef enum D3D12_QUERY_HEAP_TYPE
3036 {
3037     D3D12_QUERY_HEAP_TYPE_OCCLUSION = 0,
3038     D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1,
3039     D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2,
3040     D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3,
3041     D3D12_QUERY_HEAP_TYPE_VIDEO_DECODE_STATISTICS = 4,
3042     D3D12_QUERY_HEAP_TYPE_COPY_QUEUE_TIMESTAMP = 5,
3043     D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS1 = 7,
3044 } D3D12_QUERY_HEAP_TYPE;
3045
3046 typedef struct D3D12_QUERY_HEAP_DESC
3047 {
3048     D3D12_QUERY_HEAP_TYPE Type;
3049     UINT Count;
3050     UINT NodeMask;
3051 } D3D12_QUERY_HEAP_DESC;
3052
3053 typedef enum D3D12_INDIRECT_ARGUMENT_TYPE
3054 {
3055     D3D12_INDIRECT_ARGUMENT_TYPE_DRAW,
3056     D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED,
3057     D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH,
3058     D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW,
3059     D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW,
3060     D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT,
3061     D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW,
3062     D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW,
3063     D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW,
3064     D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_RAYS,
3065     D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH_MESH,
3066 } D3D12_INDIRECT_ARGUMENT_TYPE;
3067
3068 typedef struct D3D12_INDIRECT_ARGUMENT_DESC
3069 {
3070     D3D12_INDIRECT_ARGUMENT_TYPE Type;
3071     union
3072     {
3073         struct
3074         {
3075             UINT Slot;
3076         } VertexBuffer;
3077         struct
3078         {
3079             UINT RootParameterIndex;
3080             UINT DestOffsetIn32BitValues;
3081             UINT Num32BitValuesToSet;
3082         } Constant;
3083         struct
3084         {
3085             UINT RootParameterIndex;
3086         } ConstantBufferView;
3087         struct
3088         {
3089             UINT RootParameterIndex;
3090         } ShaderResourceView;
3091         struct
3092         {
3093             UINT RootParameterIndex;
3094         } UnorderedAccessView;
3095     };
3096 } D3D12_INDIRECT_ARGUMENT_DESC;
3097
3098 typedef struct D3D12_COMMAND_SIGNATURE_DESC
3099 {
3100     UINT ByteStride;
3101     UINT NumArgumentDescs;
3102     const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs;
3103     UINT NodeMask;
3104 } D3D12_COMMAND_SIGNATURE_DESC;
3105
3106 [
3107     uuid(c54a6b66-72df-4ee8-8be5-a946a1429214),
3108     object,
3109     local,
3110     pointer_default(unique)
3111 ]
3112 interface ID3D12RootSignature : ID3D12DeviceChild
3113 {
3114 }
3115
3116 [
3117     uuid(765a30f3-f624-4c6f-a828-ace948622445),
3118     object,
3119     local,
3120     pointer_default(unique)
3121 ]
3122 interface ID3D12PipelineState : ID3D12Pageable
3123 {
3124     HRESULT GetCachedBlob(ID3DBlob **blob);
3125 }
3126
3127 [
3128     uuid(0a753dcf-c4d8-4b91-adf6-be5a60d95a76),
3129     object,
3130     local,
3131     pointer_default(unique)
3132 ]
3133 interface ID3D12Fence : ID3D12Pageable
3134 {
3135     UINT64 GetCompletedValue();
3136     HRESULT SetEventOnCompletion(UINT64 value, HANDLE event);
3137     HRESULT Signal(UINT64 value);
3138 }
3139
3140 [
3141     uuid(433685fe-e22b-4ca0-a8db-b5b4f4dd0e4a),
3142     object,
3143     local,
3144     pointer_default(unique)
3145 ]
3146 interface ID3D12Fence1 : ID3D12Fence
3147 {
3148     D3D12_FENCE_FLAGS GetCreationFlags();
3149 }
3150
3151 [
3152     uuid(6102dee4-af59-4b09-b999-b44d73f09b24),
3153     object,
3154     local,
3155     pointer_default(unique)
3156 ]
3157 interface ID3D12CommandAllocator : ID3D12Pageable
3158 {
3159     HRESULT Reset();
3160 }
3161
3162 [
3163     uuid(189819f1-1db6-4b57-be54-1821339b85f7),
3164     object,
3165     local,
3166     pointer_default(unique)
3167 ]
3168 interface ID3D12Device : ID3D12Object
3169 {
3170     UINT GetNodeCount();
3171
3172     HRESULT CreateCommandQueue(const D3D12_COMMAND_QUEUE_DESC *desc,
3173             REFIID riid, void **command_queue);
3174     HRESULT CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE type,
3175             REFIID riid, void **command_allocator);
3176     HRESULT CreateGraphicsPipelineState(const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc,
3177             REFIID riid, void **pipeline_state);
3178     HRESULT CreateComputePipelineState(const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc,
3179             REFIID riid, void **pipeline_state);
3180     HRESULT CreateCommandList(UINT node_mask,
3181             D3D12_COMMAND_LIST_TYPE type,
3182             ID3D12CommandAllocator *command_allocator,
3183             ID3D12PipelineState *initial_pipeline_state,
3184             REFIID riid, void **command_list);
3185
3186     HRESULT CheckFeatureSupport(D3D12_FEATURE feature,
3187             void *feature_data, UINT feature_data_size);
3188
3189     HRESULT CreateDescriptorHeap(const D3D12_DESCRIPTOR_HEAP_DESC *desc,
3190             REFIID riid, void **descriptor_heap);
3191     UINT GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type);
3192
3193     HRESULT CreateRootSignature(UINT node_mask,
3194             const void *bytecode, SIZE_T bytecode_length,
3195             REFIID riid, void **root_signature);
3196
3197     void CreateConstantBufferView(const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc,
3198             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3199     void CreateShaderResourceView(ID3D12Resource *resource,
3200             const D3D12_SHADER_RESOURCE_VIEW_DESC *desc,
3201             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3202     void CreateUnorderedAccessView(ID3D12Resource *resource, ID3D12Resource *counter_resource,
3203             const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc,
3204             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3205     void CreateRenderTargetView(ID3D12Resource *resource,
3206             const D3D12_RENDER_TARGET_VIEW_DESC *desc,
3207             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3208     void CreateDepthStencilView(ID3D12Resource *resource,
3209             const D3D12_DEPTH_STENCIL_VIEW_DESC *desc,
3210             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3211     void CreateSampler(const D3D12_SAMPLER_DESC *desc,
3212             D3D12_CPU_DESCRIPTOR_HANDLE descriptor);
3213
3214     void CopyDescriptors(UINT dst_descriptor_range_count,
3215             const D3D12_CPU_DESCRIPTOR_HANDLE *dst_descriptor_range_offsets,
3216             const UINT *dst_descriptor_range_sizes,
3217             UINT src_descriptor_range_count,
3218             const D3D12_CPU_DESCRIPTOR_HANDLE *src_descriptor_range_offsets,
3219             const UINT *src_descriptor_range_sizes,
3220             D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type);
3221     void CopyDescriptorsSimple(UINT descriptor_count,
3222             const D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor_range_offset,
3223             const D3D12_CPU_DESCRIPTOR_HANDLE src_descriptor_range_offset,
3224             D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heap_type);
3225
3226     D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo(UINT visible_mask,
3227             UINT reource_desc_count, const D3D12_RESOURCE_DESC *resource_descs);
3228
3229     D3D12_HEAP_PROPERTIES GetCustomHeapProperties(UINT node_mask,
3230             D3D12_HEAP_TYPE heap_type);
3231
3232     HRESULT CreateCommittedResource(const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
3233             const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
3234             const D3D12_CLEAR_VALUE *optimized_clear_value,
3235             REFIID riid, void **resource);
3236
3237     HRESULT CreateHeap(const D3D12_HEAP_DESC *desc, REFIID riid, void **heap);
3238
3239     HRESULT CreatePlacedResource(ID3D12Heap *heap, UINT64 heap_offset,
3240             const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
3241             const D3D12_CLEAR_VALUE *optimized_clear_value,
3242             REFIID riid, void **resource);
3243     HRESULT CreateReservedResource(const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state,
3244             const D3D12_CLEAR_VALUE *optimized_clear_value,
3245             REFIID riid, void **resource);
3246
3247     HRESULT CreateSharedHandle(ID3D12DeviceChild *object,
3248             const SECURITY_ATTRIBUTES *attributes, DWORD access,
3249             const WCHAR *name, HANDLE *handle);
3250     HRESULT OpenSharedHandle(HANDLE handle,
3251             REFIID riid, void **object);
3252     HRESULT OpenSharedHandleByName(const WCHAR *name, DWORD access, HANDLE *handle);
3253
3254     HRESULT MakeResident(UINT object_count, ID3D12Pageable * const *objects);
3255     HRESULT Evict(UINT object_count, ID3D12Pageable * const *objects);
3256
3257     HRESULT CreateFence(UINT64 initial_value, D3D12_FENCE_FLAGS flags, REFIID riid, void **fence);
3258
3259     HRESULT GetDeviceRemovedReason();
3260
3261     void GetCopyableFootprints(const D3D12_RESOURCE_DESC *desc,
3262             UINT first_sub_resource,
3263             UINT sub_resource_count,
3264             UINT64 base_offset,
3265             D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts,
3266             UINT *row_count,
3267             UINT64 *row_size,
3268             UINT64 *total_bytes);
3269
3270     HRESULT CreateQueryHeap(const D3D12_QUERY_HEAP_DESC *desc,
3271             REFIID riid, void **heap);
3272
3273     HRESULT SetStablePowerState(BOOL enable);
3274
3275     HRESULT CreateCommandSignature(const D3D12_COMMAND_SIGNATURE_DESC *desc,
3276             ID3D12RootSignature *root_signature,
3277             REFIID riid, void **command_signature);
3278
3279     void GetResourceTiling(ID3D12Resource *resource,
3280             UINT *total_tile_count,
3281             D3D12_PACKED_MIP_INFO *packed_mip_info,
3282             D3D12_TILE_SHAPE *standard_tile_shape,
3283             UINT *sub_resource_tiling_count,
3284             UINT first_sub_resource_tiling,
3285             D3D12_SUBRESOURCE_TILING *sub_resource_tilings);
3286
3287     LUID GetAdapterLuid();
3288 }
3289
3290 [
3291     uuid(c64226a8-9201-46af-b4cc-53fb9ff7414f),
3292     object,
3293     local,
3294     pointer_default(unique)
3295 ]
3296 interface ID3D12PipelineLibrary : ID3D12DeviceChild
3297 {
3298     HRESULT StorePipeline(const WCHAR *name, ID3D12PipelineState *pipeline);
3299
3300     HRESULT LoadGraphicsPipeline(const WCHAR *name,
3301             const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, REFIID riid,
3302             void **pipeline_state);
3303
3304     HRESULT LoadComputePipeline(const WCHAR *name,
3305             const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, REFIID riid,
3306             void **pipeline_state);
3307
3308     SIZE_T GetSerializedSize();
3309
3310     HRESULT Serialize(void *data, SIZE_T data_size_in_bytes);
3311 }
3312
3313 [
3314     uuid(80eabf42-2568-4e5e-bd82-c37f86961dc3),
3315     object,
3316     local,
3317     pointer_default(unique)
3318 ]
3319 interface ID3D12PipelineLibrary1 : ID3D12PipelineLibrary
3320 {
3321     HRESULT LoadPipeline(const WCHAR *name,
3322             const D3D12_PIPELINE_STATE_STREAM_DESC *desc, REFIID riid,
3323             void **pipeline_state);
3324 }
3325
3326 [
3327     uuid(77acce80-638e-4e65-8895-c1f23386863e),
3328     object,
3329     local,
3330     pointer_default(unique)
3331 ]
3332 interface ID3D12Device1 : ID3D12Device
3333 {
3334     HRESULT CreatePipelineLibrary(const void *blob, SIZE_T blob_size, REFIID iid, void **lib);
3335
3336     HRESULT SetEventOnMultipleFenceCompletion(ID3D12Fence * const *fences,
3337             const UINT64 *values, UINT fence_count, D3D12_MULTIPLE_FENCE_WAIT_FLAGS flags, HANDLE event);
3338
3339     HRESULT SetResidencyPriority(UINT object_count, ID3D12Pageable * const *objects,
3340             const D3D12_RESIDENCY_PRIORITY *priorities);
3341 }
3342
3343 [
3344     uuid(30baa41e-b15b-475c-a0bb-1af5c5b64328),
3345     object,
3346     local,
3347     pointer_default(unique)
3348 ]
3349 interface ID3D12Device2 : ID3D12Device1
3350 {
3351     HRESULT CreatePipelineState(
3352         [in] const D3D12_PIPELINE_STATE_STREAM_DESC *desc,
3353         [in] REFIID riid,
3354         [out, iid_is(riid)] void **pipeline_state);
3355 }
3356
3357 [
3358     uuid(81dadc15-2bad-4392-93c5-101345c4aa98),
3359     object,
3360     local,
3361     pointer_default(unique)
3362 ]
3363 interface ID3D12Device3 : ID3D12Device2
3364 {
3365     HRESULT OpenExistingHeapFromAddress(
3366         [in] const void *address,
3367         [in] REFIID riid,
3368         [out, iid_is(riid)] void **heap);
3369
3370     HRESULT OpenExistingHeapFromFileMapping(
3371         [in] HANDLE file_mapping,
3372         [in] REFIID riid,
3373         [out, iid_is(riid)] void **heap);
3374
3375     HRESULT EnqueueMakeResident(
3376         [in] D3D12_RESIDENCY_FLAGS flags,
3377         [in] UINT num_objects,
3378         [in] ID3D12Pageable *const *objects,
3379         [in] ID3D12Fence *fence,
3380         [in] UINT64 fence_value);
3381 }
3382
3383 [
3384     uuid(34ab647b-3cc8-46ac-841b-c0965645c046),
3385     object,
3386     local,
3387     pointer_default(unique)
3388 ]
3389 interface ID3D12RootSignatureDeserializer : IUnknown
3390 {
3391     const D3D12_ROOT_SIGNATURE_DESC *GetRootSignatureDesc();
3392 }
3393
3394 [
3395     uuid(7f91ce67-090c-4bb7-b78e-ed8ff2e31da0),
3396     object,
3397     local,
3398     pointer_default(unique)
3399 ]
3400 interface ID3D12VersionedRootSignatureDeserializer : IUnknown
3401 {
3402     HRESULT GetRootSignatureDescAtVersion(D3D_ROOT_SIGNATURE_VERSION version,
3403             const D3D12_VERSIONED_ROOT_SIGNATURE_DESC **desc);
3404
3405     const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *GetUnconvertedRootSignatureDesc();
3406 };
3407
3408 typedef enum D3D12_COMMAND_LIST_FLAGS
3409 {
3410     D3D12_COMMAND_LIST_FLAG_NONE = 0x0,
3411 } D3D12_COMMAND_LIST_FLAGS;
3412 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_LIST_FLAGS);")
3413
3414 typedef enum D3D12_COMMAND_POOL_FLAGS
3415 {
3416     D3D12_COMMAND_POOL_FLAG_NONE = 0x0,
3417 } D3D12_COMMAND_POOL_FLAGS;
3418 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_POOL_FLAGS);")
3419
3420 typedef enum D3D12_COMMAND_RECORDER_FLAGS
3421 {
3422     D3D12_COMMAND_RECORDER_FLAG_NONE = 0x0,
3423 } D3D12_COMMAND_RECORDER_FLAGS;
3424 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_COMMAND_RECORDER_FLAGS);")
3425
3426 [
3427     uuid(e865df17-a9ee-46f9-a463-3098315aa2e5),
3428     object,
3429     local,
3430     pointer_default(unique)
3431 ]
3432 interface ID3D12Device4 : ID3D12Device3
3433 {
3434     HRESULT CreateCommandList1(
3435             UINT node_mask, D3D12_COMMAND_LIST_TYPE type,
3436             D3D12_COMMAND_LIST_FLAGS flags, REFIID riid,
3437             void **command_list);
3438
3439     HRESULT CreateProtectedResourceSession(
3440             const D3D12_PROTECTED_RESOURCE_SESSION_DESC *desc, REFIID riid,
3441             void **session);
3442
3443     HRESULT CreateCommittedResource1(
3444             const D3D12_HEAP_PROPERTIES *heap_properties,
3445             D3D12_HEAP_FLAGS heap_flags,
3446             const D3D12_RESOURCE_DESC *desc,
3447             D3D12_RESOURCE_STATES initial_resource_state,
3448             const D3D12_CLEAR_VALUE *optimized_clear_value,
3449             ID3D12ProtectedResourceSession *protected_session,
3450             REFIID riid_resource,
3451             void **resource);
3452
3453     HRESULT CreateHeap1(
3454             const D3D12_HEAP_DESC *desc,
3455             ID3D12ProtectedResourceSession *protected_session,
3456             REFIID riid, void **heap);
3457
3458     HRESULT CreateReservedResource1(
3459             const D3D12_RESOURCE_DESC *desc,
3460             D3D12_RESOURCE_STATES initial_state,
3461             const D3D12_CLEAR_VALUE *optimized_clear_value,
3462             ID3D12ProtectedResourceSession *protected_session,
3463             REFIID riid, void **resource);
3464
3465     D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo1(
3466             UINT visible_mask,
3467             UINT resource_descs_count,
3468             const D3D12_RESOURCE_DESC *resource_descs,
3469             D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1);
3470 }
3471
3472 typedef enum D3D12_LIFETIME_STATE
3473 {
3474     D3D12_LIFETIME_STATE_IN_USE = 0x0,
3475     D3D12_LIFETIME_STATE_NOT_IN_USE = 0x1,
3476 } D3D12_LIFETIME_STATE;
3477
3478 [
3479     uuid(e667af9f-cd56-4f46-83ce-032e595d70a8),
3480     object,
3481     local,
3482     pointer_default(unique)
3483 ]
3484 interface ID3D12LifetimeOwner : IUnknown
3485 {
3486     void LifetimeStateUpdated(D3D12_LIFETIME_STATE NewState);
3487 }
3488
3489 [
3490     uuid(f1df64b6-57fd-49cd-8807-c0eb88b45c8f),
3491     object,
3492     local,
3493     pointer_default(unique)
3494 ]
3495 interface ID3D12SwapChainAssistant : IUnknown
3496 {
3497     LUID GetLUID();
3498     HRESULT GetSwapChainObject(REFIID riid, void **ppv);
3499     HRESULT GetCurrentResourceAndCommandQueue(
3500             REFIID riid_resource, void **resource,
3501             REFIID riid_queue, void **queue);
3502     HRESULT InsertImplicitSync();
3503 }
3504
3505 [
3506     uuid(3fd03d36-4eb1-424a-a582-494ecb8ba813),
3507     object,
3508     local,
3509     pointer_default(unique)
3510 ]
3511 interface ID3D12LifetimeTracker : ID3D12DeviceChild
3512 {
3513     HRESULT DestroyOwnedObject(ID3D12DeviceChild *object);
3514 }
3515
3516 typedef enum D3D12_META_COMMAND_PARAMETER_TYPE
3517 {
3518     D3D12_META_COMMAND_PARAMETER_TYPE_FLOAT = 0x0,
3519     D3D12_META_COMMAND_PARAMETER_TYPE_UINT64 = 0x1,
3520     D3D12_META_COMMAND_PARAMETER_TYPE_GPU_VIRTUAL_ADDRESS = 0x2,
3521     D3D12_META_COMMAND_PARAMETER_TYPE_CPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x3,
3522     D3D12_META_COMMAND_PARAMETER_TYPE_GPU_DESCRIPTOR_HANDLE_HEAP_TYPE_CBV_SRV_UAV = 0x4,
3523 } D3D12_META_COMMAND_PARAMETER_TYPE;
3524
3525 typedef enum D3D12_META_COMMAND_PARAMETER_FLAGS
3526 {
3527     D3D12_META_COMMAND_PARAMETER_FLAG_INPUT = 0x1,
3528     D3D12_META_COMMAND_PARAMETER_FLAG_OUTPUT = 0x2,
3529 } D3D12_META_COMMAND_PARAMETER_FLAGS;
3530 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_META_COMMAND_PARAMETER_FLAGS);")
3531
3532 typedef enum D3D12_META_COMMAND_PARAMETER_STAGE
3533 {
3534     D3D12_META_COMMAND_PARAMETER_STAGE_CREATION = 0x0,
3535     D3D12_META_COMMAND_PARAMETER_STAGE_INITIALIZATION = 0x1,
3536     D3D12_META_COMMAND_PARAMETER_STAGE_EXECUTION = 0x2,
3537 } D3D12_META_COMMAND_PARAMETER_STAGE;
3538
3539 typedef struct D3D12_META_COMMAND_PARAMETER_DESC
3540 {
3541     const WCHAR *Name;
3542     D3D12_META_COMMAND_PARAMETER_TYPE Type;
3543     D3D12_META_COMMAND_PARAMETER_FLAGS Flags;
3544     D3D12_RESOURCE_STATES RequiredResourceState;
3545     UINT StructureOffset;
3546 } D3D12_META_COMMAND_PARAMETER_DESC;
3547
3548 typedef enum D3D12_GRAPHICS_STATES
3549 {
3550     D3D12_GRAPHICS_STATE_NONE = 0x0,
3551     D3D12_GRAPHICS_STATE_IA_VERTEX_BUFFERS = 0x1,
3552     D3D12_GRAPHICS_STATE_IA_INDEX_BUFFER = 0x2,
3553     D3D12_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY = 0x4,
3554     D3D12_GRAPHICS_STATE_DESCRIPTOR_HEAP = 0x8,
3555     D3D12_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = 0x10,
3556     D3D12_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE = 0x20,
3557     D3D12_GRAPHICS_STATE_RS_VIEWPORTS = 0x40,
3558     D3D12_GRAPHICS_STATE_RS_SCISSOR_RECTS = 0x80,
3559     D3D12_GRAPHICS_STATE_PREDICATION = 0x100,
3560     D3D12_GRAPHICS_STATE_OM_RENDER_TARGETS = 0x200,
3561     D3D12_GRAPHICS_STATE_OM_STENCIL_REF = 0x400,
3562     D3D12_GRAPHICS_STATE_OM_BLEND_FACTOR = 0x800,
3563     D3D12_GRAPHICS_STATE_PIPELINE_STATE = 0x1000,
3564     D3D12_GRAPHICS_STATE_SO_TARGETS = 0x2000,
3565     D3D12_GRAPHICS_STATE_OM_DEPTH_BOUNDS = 0x4000,
3566     D3D12_GRAPHICS_STATE_SAMPLE_POSITIONS = 0x8000,
3567     D3D12_GRAPHICS_STATE_VIEW_INSTANCE_MASK = 0x10000,
3568 } D3D12_GRAPHICS_STATES;
3569 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_GRAPHICS_STATES);")
3570
3571 typedef struct D3D12_META_COMMAND_DESC
3572 {
3573     GUID Id;
3574     const WCHAR *Name;
3575     D3D12_GRAPHICS_STATES InitializationDirtyState;
3576     D3D12_GRAPHICS_STATES ExecutionDirtyState;
3577 } D3D12_META_COMMAND_DESC;
3578
3579 [
3580     uuid(47016943-fca8-4594-93ea-af258b55346d),
3581     object,
3582     local,
3583     pointer_default(unique)
3584 ]
3585 interface ID3D12StateObject : ID3D12Pageable
3586 {
3587 }
3588
3589 [
3590     uuid(de5fa827-9bf9-4f26-89ff-d7f56fde3860),
3591     object,
3592     local,
3593     pointer_default(unique)
3594 ]
3595 interface ID3D12StateObjectProperties : IUnknown
3596 {
3597     void *GetShaderIdentifier(const WCHAR *export_name);
3598     UINT64 GetShaderStackSize(const WCHAR *export_name);
3599     UINT64 GetPipelineStackSize();
3600     void SetPipelineStackSize(UINT64 pipeline_stack_size_in_bytes);
3601 }
3602
3603 typedef enum D3D12_STATE_SUBOBJECT_TYPE
3604 {
3605     D3D12_STATE_SUBOBJECT_TYPE_STATE_OBJECT_CONFIG = 0x0,
3606     D3D12_STATE_SUBOBJECT_TYPE_GLOBAL_ROOT_SIGNATURE = 0x1,
3607     D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE = 0x2,
3608     D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK = 0x3,
3609     D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY = 0x5,
3610     D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION = 0x6,
3611     D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x7,
3612     D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION = 0x8,
3613     D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG = 0x9,
3614     D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG = 0xa,
3615     D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP = 0xb,
3616     D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG1 = 0xc,
3617     D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID = 0xd,
3618 } D3D12_STATE_SUBOBJECT_TYPE;
3619
3620 typedef struct D3D12_STATE_SUBOBJECT
3621 {
3622     D3D12_STATE_SUBOBJECT_TYPE Type;
3623     const void *pDesc;
3624 } D3D12_STATE_SUBOBJECT;
3625
3626 typedef enum D3D12_STATE_OBJECT_FLAGS
3627 {
3628     D3D12_STATE_OBJECT_FLAG_NONE = 0x0,
3629     D3D12_STATE_OBJECT_FLAG_ALLOW_LOCAL_DEPENDENCIES_ON_EXTERNAL_DEFINITIONS = 0x1,
3630     D3D12_STATE_OBJECT_FLAG_ALLOW_EXTERNAL_DEPENDENCIES_ON_LOCAL_DEFINITIONS = 0x2,
3631     D3D12_STATE_OBJECT_FLAG_ALLOW_STATE_OBJECT_ADDITIONS = 0x4,
3632 } D3D12_STATE_OBJECT_FLAGS;
3633 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_STATE_OBJECT_FLAGS);")
3634
3635 typedef struct D3D12_STATE_OBJECT_CONFIG
3636 {
3637     D3D12_STATE_OBJECT_FLAGS Flags;
3638 } D3D12_STATE_OBJECT_CONFIG;
3639
3640 typedef struct D3D12_GLOBAL_ROOT_SIGNATURE
3641 {
3642     ID3D12RootSignature *pGlobalRootSignature;
3643 } D3D12_GLOBAL_ROOT_SIGNATURE;
3644
3645 typedef struct D3D12_LOCAL_ROOT_SIGNATURE
3646 {
3647     ID3D12RootSignature *pLocalRootSignature;
3648 } D3D12_LOCAL_ROOT_SIGNATURE;
3649
3650 typedef struct D3D12_NODE_MASK
3651 {
3652     UINT NodeMask;
3653 } D3D12_NODE_MASK;
3654
3655 typedef enum D3D12_EXPORT_FLAGS
3656 {
3657     D3D12_EXPORT_FLAG_NONE = 0x0,
3658 } D3D12_EXPORT_FLAGS;
3659 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_EXPORT_FLAGS);")
3660
3661 typedef struct D3D12_EXPORT_DESC
3662 {
3663     const WCHAR *Name;
3664     const WCHAR *ExportToRename;
3665     D3D12_EXPORT_FLAGS Flags;
3666 } D3D12_EXPORT_DESC;
3667
3668 typedef struct D3D12_DXIL_LIBRARY_DESC
3669 {
3670     D3D12_SHADER_BYTECODE DXILLibrary;
3671     UINT NumExports;
3672     D3D12_EXPORT_DESC *pExports;
3673 } D3D12_DXIL_LIBRARY_DESC;
3674
3675 typedef struct D3D12_EXISTING_COLLECTION_DESC
3676 {
3677     ID3D12StateObject *pExistingCollection;
3678     UINT NumExports;
3679     D3D12_EXPORT_DESC *pExports;
3680 } D3D12_EXISTING_COLLECTION_DESC;
3681
3682 typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION
3683 {
3684     const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate;
3685     UINT NumExports;
3686     const WCHAR **pExports;
3687 } D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3688
3689 typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
3690 {
3691     const WCHAR *SubobjectToAssociate;
3692     UINT NumExports;
3693     const WCHAR **pExports;
3694 } D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
3695
3696 typedef enum D3D12_HIT_GROUP_TYPE
3697 {
3698     D3D12_HIT_GROUP_TYPE_TRIANGLES = 0x0,
3699     D3D12_HIT_GROUP_TYPE_PROCEDURAL_PRIMITIVE = 0x1,
3700 } D3D12_HIT_GROUP_TYPE;
3701
3702 typedef struct D3D12_HIT_GROUP_DESC
3703 {
3704     const WCHAR *HitGroupExport;
3705     D3D12_HIT_GROUP_TYPE Type;
3706     const WCHAR *AnyHitShaderImport;
3707     const WCHAR *ClosestHitShaderImport;
3708     const WCHAR *IntersectionShaderImport;
3709 } D3D12_HIT_GROUP_DESC;
3710
3711 typedef struct D3D12_RAYTRACING_SHADER_CONFIG
3712 {
3713     UINT MaxPayloadSizeInBytes;
3714     UINT MaxAttributeSizeInBytes;
3715 } D3D12_RAYTRACING_SHADER_CONFIG;
3716
3717 typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG
3718 {
3719     UINT MaxTraceRecursionDepth;
3720 } D3D12_RAYTRACING_PIPELINE_CONFIG;
3721
3722 typedef enum D3D12_RAYTRACING_PIPELINE_FLAGS
3723 {
3724     D3D12_RAYTRACING_PIPELINE_FLAG_NONE = 0x0,
3725     D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_TRIANGLES = 0x100,
3726     D3D12_RAYTRACING_PIPELINE_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200,
3727 } D3D12_RAYTRACING_PIPELINE_FLAGS;
3728 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_PIPELINE_FLAGS);")
3729
3730 typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG1
3731 {
3732     UINT MaxTraceRecursionDepth;
3733     D3D12_RAYTRACING_PIPELINE_FLAGS Flags;
3734 } D3D12_RAYTRACING_PIPELINE_CONFIG1;
3735
3736 typedef enum D3D12_STATE_OBJECT_TYPE
3737 {
3738     D3D12_STATE_OBJECT_TYPE_COLLECTION = 0x0,
3739     D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE = 0x3,
3740 } D3D12_STATE_OBJECT_TYPE;
3741
3742 typedef struct D3D12_STATE_OBJECT_DESC
3743 {
3744     D3D12_STATE_OBJECT_TYPE Type;
3745     UINT NumSubobjects;
3746     const D3D12_STATE_SUBOBJECT *pSubobjects;
3747 } D3D12_STATE_OBJECT_DESC;
3748
3749 typedef enum D3D12_RAYTRACING_GEOMETRY_FLAGS
3750 {
3751     D3D12_RAYTRACING_GEOMETRY_FLAG_NONE = 0x0,
3752     D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE = 0x1,
3753     D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION = 0x2,
3754 } D3D12_RAYTRACING_GEOMETRY_FLAGS;
3755 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_GEOMETRY_FLAGS);")
3756
3757 typedef enum D3D12_RAYTRACING_GEOMETRY_TYPE
3758 {
3759     D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES = 0x0,
3760     D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS = 0x1,
3761 } D3D12_RAYTRACING_GEOMETRY_TYPE;
3762
3763 typedef enum D3D12_RAYTRACING_INSTANCE_FLAGS
3764 {
3765     D3D12_RAYTRACING_INSTANCE_FLAG_NONE = 0x0,
3766     D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE = 0x1,
3767     D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE = 0x2,
3768     D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE = 0x4,
3769     D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE = 0x8
3770 } D3D12_RAYTRACING_INSTANCE_FLAGS;
3771 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_INSTANCE_FLAGS);")
3772
3773 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE
3774 {
3775     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
3776     UINT64 StrideInBytes;
3777 } D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE;
3778
3779 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE
3780 {
3781     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
3782     UINT64 SizeInBytes;
3783 } D3D12_GPU_VIRTUAL_ADDRESS_RANGE;
3784
3785 typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE
3786 {
3787     D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
3788     UINT64 SizeInBytes;
3789     UINT64 StrideInBytes;
3790 } D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE;
3791
3792 typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC
3793 {
3794     D3D12_GPU_VIRTUAL_ADDRESS Transform3x4;
3795     DXGI_FORMAT IndexFormat;
3796     DXGI_FORMAT VertexFormat;
3797     UINT IndexCount;
3798     UINT VertexCount;
3799     D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer;
3800     D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer;
3801 } D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC;
3802
3803 typedef struct D3D12_RAYTRACING_AABB
3804 {
3805     FLOAT MinX;
3806     FLOAT MinY;
3807     FLOAT MinZ;
3808     FLOAT MaxX;
3809     FLOAT MaxY;
3810     FLOAT MaxZ;
3811 } D3D12_RAYTRACING_AABB;
3812
3813 typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC
3814 {
3815     UINT64 AABBCount;
3816     D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs;
3817 } D3D12_RAYTRACING_GEOMETRY_AABBS_DESC;
3818
3819 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS
3820 {
3821     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE = 0x00,
3822     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE = 0x01,
3823     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION = 0x02,
3824     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE = 0x04,
3825     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD = 0x08,
3826     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY = 0x10,
3827     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE = 0x20,
3828 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
3829 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS);")
3830
3831 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE
3832 {
3833     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE = 0x0,
3834     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT = 0x1,
3835     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS = 0x2,
3836     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE = 0x3,
3837     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE = 0x4,
3838 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE;
3839
3840 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE
3841 {
3842     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL = 0x0,
3843     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL = 0x1
3844 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE;
3845
3846 typedef enum D3D12_ELEMENTS_LAYOUT
3847 {
3848     D3D12_ELEMENTS_LAYOUT_ARRAY = 0x0,
3849     D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS = 0x1
3850 } D3D12_ELEMENTS_LAYOUT;
3851
3852 typedef enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE
3853 {
3854     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE = 0x0,
3855     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION  = 0x1,
3856     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION  = 0x2,
3857     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE  = 0x3,
3858 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE;
3859
3860 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC
3861 {
3862     D3D12_GPU_VIRTUAL_ADDRESS DestBuffer;
3863     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType;
3864 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC;
3865
3866 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC
3867 {
3868     UINT64 CompactedSizeInBytes;
3869 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC;
3870
3871 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC
3872 {
3873     UINT64 DecodedSizeInBytes;
3874 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC;
3875
3876 typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER
3877 {
3878     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
3879     UINT NumDescs;
3880 } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER;
3881
3882 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC
3883 {
3884     UINT64 SerializedSizeInBytes;
3885     UINT64 NumBottomLevelAccelerationStructurePointers;
3886 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC;
3887
3888 typedef struct D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER
3889 {
3890     GUID DriverOpaqueGUID;
3891     BYTE DriverOpaqueVersioningData[16];
3892 } D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER;
3893
3894 typedef enum D3D12_SERIALIZED_DATA_TYPE
3895 {
3896     D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE = 0x0,
3897 } D3D12_SERIALIZED_DATA_TYPE;
3898
3899 typedef enum D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS
3900 {
3901     D3D12_DRIVER_MATCHING_IDENTIFIER_COMPATIBLE_WITH_DEVICE = 0x0,
3902     D3D12_DRIVER_MATCHING_IDENTIFIER_UNSUPPORTED_TYPE = 0x1,
3903     D3D12_DRIVER_MATCHING_IDENTIFIER_UNRECOGNIZED = 0x2,
3904     D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_VERSION = 0x3,
3905     D3D12_DRIVER_MATCHING_IDENTIFIER_INCOMPATIBLE_TYPE = 0x4,
3906 } D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS;
3907
3908 typedef struct D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER
3909 {
3910     D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER DriverMatchingIdentifier;
3911     UINT64 SerializedSizeInBytesIncludingHeader;
3912     UINT64 DeserializedSizeInBytes;
3913     UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader;
3914 } D3D12_SERIALIZED_RAYTRACING_ACCELERATION_STRUCTURE_HEADER;
3915
3916 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC
3917 {
3918     UINT64 CurrentSizeInBytes;
3919 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_CURRENT_SIZE_DESC;
3920
3921 typedef struct D3D12_RAYTRACING_INSTANCE_DESC
3922 {
3923     FLOAT Transform[3][4];
3924     UINT InstanceID : 24;
3925     UINT InstanceMask : 8;
3926     UINT InstanceContributionToHitGroupIndex : 24;
3927     UINT Flags : 8;
3928     D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure;
3929 } D3D12_RAYTRACING_INSTANCE_DESC;
3930
3931 typedef struct D3D12_RAYTRACING_GEOMETRY_DESC
3932 {
3933     D3D12_RAYTRACING_GEOMETRY_TYPE Type;
3934     D3D12_RAYTRACING_GEOMETRY_FLAGS Flags;
3935     union
3936     {
3937         D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles;
3938         D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs;
3939     };
3940 } D3D12_RAYTRACING_GEOMETRY_DESC;
3941
3942 typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS
3943 {
3944     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
3945     D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags;
3946     UINT NumDescs;
3947     D3D12_ELEMENTS_LAYOUT DescsLayout;
3948     union
3949     {
3950         D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs;
3951         const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs;
3952         const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs;
3953     };
3954 } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS;
3955
3956 typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC
3957 {
3958     D3D12_GPU_VIRTUAL_ADDRESS DestAccelerationStructureData;
3959     D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS Inputs;
3960     D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData;
3961     D3D12_GPU_VIRTUAL_ADDRESS ScratchAccelerationStructureData;
3962 } D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC;
3963
3964 typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO
3965 {
3966     UINT64 ResultDataMaxSizeInBytes;
3967     UINT64 ScratchDataSizeInBytes;
3968     UINT64 UpdateScratchDataSizeInBytes;
3969 } D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO;
3970
3971 typedef enum D3D12_RAY_FLAGS
3972 {
3973     D3D12_RAY_FLAG_NONE = 0x00,
3974     D3D12_RAY_FLAG_FORCE_OPAQUE = 0x01,
3975     D3D12_RAY_FLAG_FORCE_NON_OPAQUE = 0x02,
3976     D3D12_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH = 0x04,
3977     D3D12_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER = 0x08,
3978     D3D12_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 0x10,
3979     D3D12_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 0x20,
3980     D3D12_RAY_FLAG_CULL_OPAQUE = 0x40,
3981     D3D12_RAY_FLAG_CULL_NON_OPAQUE = 0x80,
3982     D3D12_RAY_FLAG_SKIP_TRIANGLES = 0x100,
3983     D3D12_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES = 0x200,
3984 } D3D12_RAY_FLAGS;
3985 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RAY_FLAGS);")
3986
3987 typedef enum D3D12_HIT_KIND
3988 {
3989     D3D12_HIT_KIND_TRIANGLE_FRONT_FACE = 0xfe,
3990     D3D12_HIT_KIND_TRIANGLE_BACK_FACE = 0xff,
3991 } D3D12_HIT_KIND;
3992
3993 [
3994     uuid(8b4f173b-2fea-4b80-8f58-4307191ab95d),
3995     object,
3996     local,
3997     pointer_default(unique)
3998 ]
3999 interface ID3D12Device5 : ID3D12Device4
4000 {
4001     HRESULT CreateLifetimeTracker(
4002             ID3D12LifetimeOwner *owner, REFIID riid,
4003             void **tracker);
4004
4005     void RemoveDevice();
4006
4007     HRESULT EnumerateMetaCommands(
4008             UINT *meta_commands_count,
4009             D3D12_META_COMMAND_DESC *descs);
4010
4011     HRESULT EnumerateMetaCommandParameters(
4012             REFGUID command_id,
4013             D3D12_META_COMMAND_PARAMETER_STAGE stage,
4014             UINT *total_structure_size_in_bytes,
4015             UINT *parameter_count,
4016             D3D12_META_COMMAND_PARAMETER_DESC *parameter_descs);
4017
4018     HRESULT CreateMetaCommand(
4019             REFGUID command_id, UINT node_mask,
4020             const void *creation_parameters_data,
4021             SIZE_T creation_parameters_data_size_in_bytes,
4022             REFIID riid, void **meta_command);
4023
4024     HRESULT CreateStateObject(
4025             const D3D12_STATE_OBJECT_DESC *desc, REFIID riid,
4026             void **state_object);
4027
4028     void GetRaytracingAccelerationStructurePrebuildInfo(
4029             const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS *desc,
4030             D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *info);
4031
4032     D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS CheckDriverMatchingIdentifier(
4033             D3D12_SERIALIZED_DATA_TYPE serialized_data_type,
4034             const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER *identifier_to_check);
4035 }
4036
4037 typedef enum D3D12_AUTO_BREADCRUMB_OP
4038 {
4039     D3D12_AUTO_BREADCRUMB_OP_SETMARKER = 0x0,
4040     D3D12_AUTO_BREADCRUMB_OP_BEGINEVENT = 0x1,
4041     D3D12_AUTO_BREADCRUMB_OP_ENDEVENT = 0x2,
4042     D3D12_AUTO_BREADCRUMB_OP_DRAWINSTANCED = 0x3,
4043     D3D12_AUTO_BREADCRUMB_OP_DRAWINDEXEDINSTANCED = 0x4,
4044     D3D12_AUTO_BREADCRUMB_OP_EXECUTEINDIRECT = 0x5,
4045     D3D12_AUTO_BREADCRUMB_OP_DISPATCH = 0x6,
4046     D3D12_AUTO_BREADCRUMB_OP_COPYBUFFERREGION = 0x7,
4047     D3D12_AUTO_BREADCRUMB_OP_COPYTEXTUREREGION = 0x8,
4048     D3D12_AUTO_BREADCRUMB_OP_COPYRESOURCE = 0x9,
4049     D3D12_AUTO_BREADCRUMB_OP_COPYTILES = 0xa,
4050     D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCE = 0xb,
4051     D3D12_AUTO_BREADCRUMB_OP_CLEARRENDERTARGETVIEW = 0xc,
4052     D3D12_AUTO_BREADCRUMB_OP_CLEARUNORDEREDACCESSVIEW = 0xd,
4053     D3D12_AUTO_BREADCRUMB_OP_CLEARDEPTHSTENCILVIEW = 0xe,
4054     D3D12_AUTO_BREADCRUMB_OP_RESOURCEBARRIER = 0xf,
4055     D3D12_AUTO_BREADCRUMB_OP_EXECUTEBUNDLE = 0x10,
4056     D3D12_AUTO_BREADCRUMB_OP_PRESENT = 0x11,
4057     D3D12_AUTO_BREADCRUMB_OP_RESOLVEQUERYDATA = 0x12,
4058     D3D12_AUTO_BREADCRUMB_OP_BEGINSUBMISSION = 0x13,
4059     D3D12_AUTO_BREADCRUMB_OP_ENDSUBMISSION = 0x14,
4060     D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME = 0x15,
4061     D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES = 0x16,
4062     D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT = 0x17,
4063     D3D12_AUTO_BREADCRUMB_OP_ATOMICCOPYBUFFERUINT64 = 0x18,
4064     D3D12_AUTO_BREADCRUMB_OP_RESOLVESUBRESOURCEREGION = 0x19,
4065     D3D12_AUTO_BREADCRUMB_OP_WRITEBUFFERIMMEDIATE = 0x1a,
4066     D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME1 = 0x1b,
4067     D3D12_AUTO_BREADCRUMB_OP_SETPROTECTEDRESOURCESESSION = 0x1c,
4068     D3D12_AUTO_BREADCRUMB_OP_DECODEFRAME2 = 0x1d,
4069     D3D12_AUTO_BREADCRUMB_OP_PROCESSFRAMES1 = 0x1e,
4070     D3D12_AUTO_BREADCRUMB_OP_BUILDRAYTRACINGACCELERATIONSTRUCTURE = 0x1f,
4071     D3D12_AUTO_BREADCRUMB_OP_EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 0x20,
4072     D3D12_AUTO_BREADCRUMB_OP_COPYRAYTRACINGACCELERATIONSTRUCTURE = 0x21,
4073     D3D12_AUTO_BREADCRUMB_OP_DISPATCHRAYS = 0x22,
4074     D3D12_AUTO_BREADCRUMB_OP_INITIALIZEMETACOMMAND = 0x23,
4075     D3D12_AUTO_BREADCRUMB_OP_EXECUTEMETACOMMAND = 0x24,
4076     D3D12_AUTO_BREADCRUMB_OP_ESTIMATEMOTION = 0x25,
4077     D3D12_AUTO_BREADCRUMB_OP_RESOLVEMOTIONVECTORHEAP = 0x26,
4078     D3D12_AUTO_BREADCRUMB_OP_SETPIPELINESTATE1 = 0x27,
4079     D3D12_AUTO_BREADCRUMB_OP_INITIALIZEEXTENSIONCOMMAND = 0x28,
4080     D3D12_AUTO_BREADCRUMB_OP_EXECUTEEXTENSIONCOMMAND = 0x29,
4081     D3D12_AUTO_BREADCRUMB_OP_DISPATCHMESH = 0x2a,
4082     D3D12_AUTO_BREADCRUMB_OP_ENCODEFRAME = 0x2b,
4083     D3D12_AUTO_BREADCRUMB_OP_RESOLVEENCODEROUTPUTMETADATA = 0x2c,
4084 } D3D12_AUTO_BREADCRUMB_OP;
4085
4086 typedef struct D3D12_AUTO_BREADCRUMB_NODE
4087 {
4088     const char *pCommandListDebugNameA;
4089     const WCHAR *pCommandListDebugNameW;
4090     const char *pCommandQueueDebugNameA;
4091     const WCHAR *pCommandQueueDebugNameW;
4092     ID3D12GraphicsCommandList *pCommandList;
4093     ID3D12CommandQueue *pCommandQueue;
4094     UINT32 BreadcrumbCount;
4095     const UINT32 *pLastBreadcrumbValue;
4096     const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
4097     const struct D3D12_AUTO_BREADCRUMB_NODE *pNext;
4098 } D3D12_AUTO_BREADCRUMB_NODE;
4099
4100 typedef struct D3D12_DRED_BREADCRUMB_CONTEXT
4101 {
4102     UINT BreadcrumbIndex;
4103     const WCHAR *pContextString;
4104 } D3D12_DRED_BREADCRUMB_CONTEXT;
4105
4106 typedef struct D3D12_AUTO_BREADCRUMB_NODE1
4107 {
4108     const char *pCommandListDebugNameA;
4109     const WCHAR *pCommandListDebugNameW;
4110     const char *pCommandQueueDebugNameA;
4111     const WCHAR *pCommandQueueDebugNameW;
4112     ID3D12GraphicsCommandList *pCommandList;
4113     ID3D12CommandQueue *pCommandQueue;
4114     UINT BreadcrumbCount;
4115     const UINT *pLastBreadcrumbValue;
4116     const D3D12_AUTO_BREADCRUMB_OP *pCommandHistory;
4117     const struct D3D12_AUTO_BREADCRUMB_NODE1 *pNext;
4118     UINT BreadcrumbContextsCount;
4119     D3D12_DRED_BREADCRUMB_CONTEXT *pBreadcrumbContexts;
4120 } D3D12_AUTO_BREADCRUMB_NODE1;
4121
4122 typedef enum D3D12_DRED_VERSION
4123 {
4124     D3D12_DRED_VERSION_1_0 = 0x1,
4125     D3D12_DRED_VERSION_1_1 = 0x2,
4126     D3D12_DRED_VERSION_1_2 = 0x3,
4127     D3D12_DRED_VERSION_1_3 = 0x4,
4128 } D3D12_DRED_VERSION;
4129
4130 typedef enum D3D12_DRED_FLAGS
4131 {
4132     D3D12_DRED_FLAG_NONE = 0x0,
4133     D3D12_DRED_FLAG_FORCE_ENABLE = 0x1,
4134     D3D12_DRED_FLAG_DISABLE_AUTOBREADCRUMBS = 0x2,
4135 } D3D12_DRED_FLAGS;
4136 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_FLAGS);")
4137
4138 typedef enum D3D12_DRED_ENABLEMENT
4139 {
4140     D3D12_DRED_ENABLEMENT_SYSTEM_CONTROLLED = 0x0,
4141     D3D12_DRED_ENABLEMENT_FORCED_OFF = 0x1,
4142     D3D12_DRED_ENABLEMENT_FORCED_ON = 0x2,
4143 } D3D12_DRED_ENABLEMENT;
4144
4145 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA
4146 {
4147     D3D12_DRED_FLAGS Flags;
4148     D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
4149 } D3D12_DEVICE_REMOVED_EXTENDED_DATA;
4150
4151 typedef enum D3D12_DRED_ALLOCATION_TYPE
4152 {
4153     D3D12_DRED_ALLOCATION_TYPE_COMMAND_QUEUE = 0x13,
4154     D3D12_DRED_ALLOCATION_TYPE_COMMAND_ALLOCATOR = 0x14,
4155     D3D12_DRED_ALLOCATION_TYPE_PIPELINE_STATE = 0x15,
4156     D3D12_DRED_ALLOCATION_TYPE_COMMAND_LIST = 0x16,
4157     D3D12_DRED_ALLOCATION_TYPE_FENCE = 0x17,
4158     D3D12_DRED_ALLOCATION_TYPE_DESCRIPTOR_HEAP = 0x18,
4159     D3D12_DRED_ALLOCATION_TYPE_HEAP = 0x19,
4160     D3D12_DRED_ALLOCATION_TYPE_QUERY_HEAP = 0x1b,
4161     D3D12_DRED_ALLOCATION_TYPE_COMMAND_SIGNATURE = 0x1c,
4162     D3D12_DRED_ALLOCATION_TYPE_PIPELINE_LIBRARY = 0x1d,
4163     D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER = 0x1e,
4164     D3D12_DRED_ALLOCATION_TYPE_VIDEO_PROCESSOR = 0x20,
4165     D3D12_DRED_ALLOCATION_TYPE_RESOURCE = 0x22,
4166     D3D12_DRED_ALLOCATION_TYPE_PASS = 0x23,
4167     D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSION = 0x24,
4168     D3D12_DRED_ALLOCATION_TYPE_CRYPTOSESSIONPOLICY = 0x25,
4169     D3D12_DRED_ALLOCATION_TYPE_PROTECTEDRESOURCESESSION = 0x26,
4170     D3D12_DRED_ALLOCATION_TYPE_VIDEO_DECODER_HEAP = 0x27,
4171     D3D12_DRED_ALLOCATION_TYPE_COMMAND_POOL = 0x28,
4172     D3D12_DRED_ALLOCATION_TYPE_COMMAND_RECORDER = 0x29,
4173     D3D12_DRED_ALLOCATION_TYPE_STATE_OBJECT = 0x2a,
4174     D3D12_DRED_ALLOCATION_TYPE_METACOMMAND = 0x2b,
4175     D3D12_DRED_ALLOCATION_TYPE_SCHEDULINGGROUP = 0x2c,
4176     D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_ESTIMATOR = 0x2d,
4177     D3D12_DRED_ALLOCATION_TYPE_VIDEO_MOTION_VECTOR_HEAP = 0x2e,
4178     D3D12_DRED_ALLOCATION_TYPE_VIDEO_EXTENSION_COMMAND = 0x2f,
4179     D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER = 0x30,
4180     D3D12_DRED_ALLOCATION_TYPE_VIDEO_ENCODER_HEAP = 0x31,
4181     D3D12_DRED_ALLOCATION_TYPE_INVALID = 0xffffffff,
4182 } D3D12_DRED_ALLOCATION_TYPE;
4183
4184 typedef struct D3D12_DRED_ALLOCATION_NODE
4185 {
4186     const char *ObjectNameA;
4187     const WCHAR *ObjectNameW;
4188     D3D12_DRED_ALLOCATION_TYPE AllocationType;
4189     const struct D3D12_DRED_ALLOCATION_NODE *pNext;
4190 } D3D12_DRED_ALLOCATION_NODE;
4191
4192 typedef struct D3D12_DRED_ALLOCATION_NODE1
4193 {
4194     const char *ObjectNameA;
4195     const WCHAR *ObjectNameW;
4196     D3D12_DRED_ALLOCATION_TYPE AllocationType;
4197     const struct D3D12_DRED_ALLOCATION_NODE1 *pNext;
4198     const IUnknown *pObject;
4199 } D3D12_DRED_ALLOCATION_NODE1;
4200
4201 typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT
4202 {
4203     const D3D12_AUTO_BREADCRUMB_NODE *pHeadAutoBreadcrumbNode;
4204 } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT;
4205
4206 typedef struct D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1
4207 {
4208     const D3D12_AUTO_BREADCRUMB_NODE1 *pHeadAutoBreadcrumbNode;
4209 } D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1;
4210
4211 typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT
4212 {
4213     D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
4214     const D3D12_DRED_ALLOCATION_NODE *pHeadExistingAllocationNode;
4215     const D3D12_DRED_ALLOCATION_NODE *pHeadRecentFreedAllocationNode;
4216 } D3D12_DRED_PAGE_FAULT_OUTPUT;
4217
4218 typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT1
4219 {
4220     D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
4221     const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
4222     const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
4223 } D3D12_DRED_PAGE_FAULT_OUTPUT1;
4224
4225 typedef enum D3D12_DRED_PAGE_FAULT_FLAGS
4226 {
4227     D3D12_DRED_PAGE_FAULT_FLAGS_NONE = 0x0,
4228 } D3D12_DRED_PAGE_FAULT_FLAGS;
4229 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_DRED_PAGE_FAULT_FLAGS);")
4230
4231 typedef enum D3D12_DRED_DEVICE_STATE
4232 {
4233     D3D12_DRED_DEVICE_STATE_UNKNOWN = 0x0,
4234     D3D12_DRED_DEVICE_STATE_HUNG = 0x3,
4235     D3D12_DRED_DEVICE_STATE_FAULT = 0x6,
4236     D3D12_DRED_DEVICE_STATE_PAGEFAULT = 0x7,
4237 } D3D12_DRED_DEVICE_STATE;
4238
4239 typedef struct D3D12_DRED_PAGE_FAULT_OUTPUT2
4240 {
4241     D3D12_GPU_VIRTUAL_ADDRESS PageFaultVA;
4242     const D3D12_DRED_ALLOCATION_NODE1 *pHeadExistingAllocationNode;
4243     const D3D12_DRED_ALLOCATION_NODE1 *pHeadRecentFreedAllocationNode;
4244     D3D12_DRED_PAGE_FAULT_FLAGS PageFaultFlags;
4245 } D3D12_DRED_PAGE_FAULT_OUTPUT2;
4246
4247 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA1
4248 {
4249     HRESULT DeviceRemovedReason;
4250     D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT AutoBreadcrumbsOutput;
4251     D3D12_DRED_PAGE_FAULT_OUTPUT PageFaultOutput;
4252 } D3D12_DEVICE_REMOVED_EXTENDED_DATA1;
4253
4254 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA2
4255 {
4256     HRESULT DeviceRemovedReason;
4257     D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
4258     D3D12_DRED_PAGE_FAULT_OUTPUT1 PageFaultOutput;
4259 } D3D12_DEVICE_REMOVED_EXTENDED_DATA2;
4260
4261 typedef struct D3D12_DEVICE_REMOVED_EXTENDED_DATA3
4262 {
4263     HRESULT DeviceRemovedReason;
4264     D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 AutoBreadcrumbsOutput;
4265     D3D12_DRED_PAGE_FAULT_OUTPUT2 PageFaultOutput;
4266     D3D12_DRED_DEVICE_STATE DeviceState;
4267 } D3D12_DEVICE_REMOVED_EXTENDED_DATA3;
4268
4269 typedef struct D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA
4270 {
4271     D3D12_DRED_VERSION Version;
4272     union
4273     {
4274         D3D12_DEVICE_REMOVED_EXTENDED_DATA Dred_1_0;
4275         D3D12_DEVICE_REMOVED_EXTENDED_DATA1 Dred_1_1;
4276         D3D12_DEVICE_REMOVED_EXTENDED_DATA2 Dred_1_2;
4277         D3D12_DEVICE_REMOVED_EXTENDED_DATA3 Dred_1_3;
4278     };
4279 } D3D12_VERSIONED_DEVICE_REMOVED_EXTENDED_DATA;
4280
4281 [
4282     uuid(82bc481c-6b9b-4030-aedb-7ee3d1df1e63),
4283     object,
4284     local,
4285     pointer_default(unique)
4286 ]
4287 interface ID3D12DeviceRemovedExtendedDataSettings : IUnknown
4288 {
4289     void SetAutoBreadcrumbsEnablement(D3D12_DRED_ENABLEMENT enablement);
4290     void SetPageFaultEnablement(D3D12_DRED_ENABLEMENT enablement);
4291     void SetWatsonDumpEnablement(D3D12_DRED_ENABLEMENT enablement);
4292 }
4293
4294 [
4295     uuid(dbd5ae51-3317-4f0a-adf9-1d7cedcaae0b),
4296     object,
4297     local,
4298     pointer_default(unique)
4299 ]
4300 interface ID3D12DeviceRemovedExtendedDataSettings1 : ID3D12DeviceRemovedExtendedDataSettings
4301 {
4302     void SetBreadcrumbContextEnablement(D3D12_DRED_ENABLEMENT enablement);
4303 }
4304
4305 [
4306     uuid(98931d33-5ae8-4791-aa3c-1a73a2934e71),
4307     object,
4308     local,
4309     pointer_default(unique)
4310 ]
4311 interface ID3D12DeviceRemovedExtendedData : IUnknown
4312 {
4313     HRESULT GetAutoBreadcrumbsOutput(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT *output);
4314     HRESULT GetPageFaultAllocationOutput(D3D12_DRED_PAGE_FAULT_OUTPUT *output);
4315 }
4316
4317 [
4318     uuid(9727a022-cf1d-4dda-9eba-effa653fc506),
4319     object,
4320     local,
4321     pointer_default(unique)
4322 ]
4323 interface ID3D12DeviceRemovedExtendedData1 : ID3D12DeviceRemovedExtendedData
4324 {
4325     HRESULT GetAutoBreadcrumbsOutput1(D3D12_DRED_AUTO_BREADCRUMBS_OUTPUT1 *output);
4326     HRESULT GetPageFaultAllocationOutput1(D3D12_DRED_PAGE_FAULT_OUTPUT1 *output);
4327 }
4328
4329 [
4330     uuid(67fc5816-e4ca-4915-bf18-42541272da54),
4331     object,
4332     local,
4333     pointer_default(unique)
4334 ]
4335 interface ID3D12DeviceRemovedExtendedData2 : ID3D12DeviceRemovedExtendedData1
4336 {
4337     HRESULT GetPageFaultAllocationOutput2(D3D12_DRED_PAGE_FAULT_OUTPUT2 *output);
4338     D3D12_DRED_DEVICE_STATE GetDeviceState();
4339 }
4340
4341 typedef enum D3D12_BACKGROUND_PROCESSING_MODE
4342 {
4343     D3D12_BACKGROUND_PROCESSING_MODE_ALLOWED = 0x0,
4344     D3D12_BACKGROUND_PROCESSING_MODE_ALLOW_INTRUSIVE_MEASUREMENTS = 0x1,
4345     D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_BACKGROUND_WORK = 0x2,
4346     D3D12_BACKGROUND_PROCESSING_MODE_DISABLE_PROFILING_BY_SYSTEM = 0x3,
4347 } D3D12_BACKGROUND_PROCESSING_MODE;
4348
4349 typedef enum D3D12_MEASUREMENTS_ACTION
4350 {
4351     D3D12_MEASUREMENTS_ACTION_KEEP_ALL = 0x0,
4352     D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS = 0x1,
4353     D3D12_MEASUREMENTS_ACTION_COMMIT_RESULTS_HIGH_PRIORITY = 0x2,
4354     D3D12_MEASUREMENTS_ACTION_DISCARD_PREVIOUS = 0x3,
4355 } D3D12_MEASUREMENTS_ACTION;
4356
4357 [
4358     uuid(c70b221b-40e4-4a17-89af-025a0727a6dc),
4359     object,
4360     local,
4361     pointer_default(unique)
4362 ]
4363 interface ID3D12Device6 : ID3D12Device5
4364 {
4365     HRESULT SetBackgroundProcessingMode(
4366             D3D12_BACKGROUND_PROCESSING_MODE mode,
4367             D3D12_MEASUREMENTS_ACTION action,
4368             HANDLE event,
4369             BOOL *further_measurements_desired);
4370 }
4371
4372 cpp_quote("DEFINE_GUID(D3D12_PROTECTED_RESOURCES_SESSION_HARDWARE_PROTECTED, 0x62b0084e, 0xc70e, 0x4daa, 0xa1, 0x09, 0x30, 0xff, 0x8d, 0x5a, 0x04, 0x82);")
4373
4374 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT
4375 {
4376     UINT NodeIndex;
4377     UINT Count;
4378 } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT;
4379
4380 typedef struct D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES
4381 {
4382     UINT NodeIndex;
4383     UINT Count;
4384     GUID *pTypes;
4385 } D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES;
4386
4387 typedef struct D3D12_PROTECTED_RESOURCE_SESSION_DESC1
4388 {
4389     UINT NodeMask;
4390     D3D12_PROTECTED_RESOURCE_SESSION_FLAGS Flags;
4391     GUID ProtectionType;
4392 } D3D12_PROTECTED_RESOURCE_SESSION_DESC1;
4393
4394 [
4395     uuid(d6f12dd6-76fb-406e-8961-4296eefc0409),
4396     object,
4397     local,
4398     pointer_default(unique)
4399 ]
4400 interface ID3D12ProtectedResourceSession1 : ID3D12ProtectedResourceSession
4401 {
4402     D3D12_PROTECTED_RESOURCE_SESSION_DESC1 GetDesc1();
4403 }
4404
4405 [
4406     uuid(5c014b53-68a1-4b9b-8bd1-dd6046b9358b),
4407     object,
4408     local,
4409     pointer_default(unique)
4410 ]
4411 interface ID3D12Device7 : ID3D12Device6
4412 {
4413     HRESULT AddToStateObject(
4414             const D3D12_STATE_OBJECT_DESC *addition,
4415             ID3D12StateObject *state_object_to_grow_from,
4416             REFIID riid, void **new_state_object);
4417
4418     HRESULT CreateProtectedResourceSession1(
4419             const D3D12_PROTECTED_RESOURCE_SESSION_DESC1 *desc,
4420             REFIID riid, void **session);
4421 }
4422
4423 [
4424     uuid(9218e6bb-f944-4f7e-a75c-b1b2c7b701f3),
4425     object,
4426     local,
4427     pointer_default(unique)
4428 ]
4429 interface ID3D12Device8 : ID3D12Device7
4430 {
4431     D3D12_RESOURCE_ALLOCATION_INFO GetResourceAllocationInfo2(
4432             UINT visible_mask,
4433             UINT resource_descs_count,
4434             const D3D12_RESOURCE_DESC1 *resource_descs,
4435             D3D12_RESOURCE_ALLOCATION_INFO1 *resource_allocation_info1);
4436
4437     HRESULT CreateCommittedResource2(
4438             const D3D12_HEAP_PROPERTIES *heap_properties,
4439             D3D12_HEAP_FLAGS heap_flags,
4440             const D3D12_RESOURCE_DESC1 *desc,
4441             D3D12_RESOURCE_STATES initial_resource_state,
4442             const D3D12_CLEAR_VALUE *optimized_clear_value,
4443             ID3D12ProtectedResourceSession *protected_session,
4444             REFIID riid_resource, void **resource);
4445
4446     HRESULT CreatePlacedResource1(
4447             ID3D12Heap *heap,
4448             UINT64 heap_offset,
4449             const D3D12_RESOURCE_DESC1 *desc,
4450             D3D12_RESOURCE_STATES initial_state,
4451             const D3D12_CLEAR_VALUE *optimized_clear_value,
4452             REFIID riid, void **resource);
4453
4454     void CreateSamplerFeedbackUnorderedAccessView(
4455             ID3D12Resource *targeted_resource,
4456             ID3D12Resource *feedback_resource,
4457             D3D12_CPU_DESCRIPTOR_HANDLE dst_descriptor);
4458
4459     void GetCopyableFootprints1(
4460             const D3D12_RESOURCE_DESC1 *resource_desc,
4461             UINT first_subresource,
4462             UINT subresources_count,
4463             UINT64 base_offset,
4464             D3D12_PLACED_SUBRESOURCE_FOOTPRINT *layouts,
4465             UINT *rows_count,
4466             UINT64 *row_size_in_bytes,
4467             UINT64 *total_bytes);
4468 }
4469
4470 [
4471     uuid(9d5e227a-4430-4161-88b3-3eca6bb16e19),
4472     object,
4473     local,
4474     pointer_default(unique)
4475 ]
4476 interface ID3D12Resource1 : ID3D12Resource
4477 {
4478     HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session);
4479 }
4480
4481 [
4482     uuid(be36ec3b-ea85-4aeb-a45a-e9d76404a495),
4483     object,
4484     local,
4485     pointer_default(unique)
4486 ]
4487 interface ID3D12Resource2 : ID3D12Resource1
4488 {
4489     D3D12_RESOURCE_DESC1 GetDesc1();
4490 }
4491
4492 [
4493     uuid(572f7389-2168-49e3-9693-d6df5871bf6d),
4494     object,
4495     local,
4496     pointer_default(unique)
4497 ]
4498 interface ID3D12Heap1 : ID3D12Heap
4499 {
4500     HRESULT GetProtectedResourceSession(REFIID riid, void **protected_session);
4501 }
4502
4503 typedef enum D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE
4504 {
4505     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_DISCARD = 0x0,
4506     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_PRESERVE = 0x1,
4507     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_CLEAR = 0x2,
4508     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE_NO_ACCESS = 0x3,
4509 } D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE;
4510
4511 typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS
4512 {
4513     D3D12_CLEAR_VALUE ClearValue;
4514 } D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS;
4515
4516 typedef struct D3D12_RENDER_PASS_BEGINNING_ACCESS
4517 {
4518     D3D12_RENDER_PASS_BEGINNING_ACCESS_TYPE Type;
4519
4520     union
4521     {
4522         D3D12_RENDER_PASS_BEGINNING_ACCESS_CLEAR_PARAMETERS Clear;
4523     };
4524 } D3D12_RENDER_PASS_BEGINNING_ACCESS;
4525
4526 typedef enum D3D12_RENDER_PASS_ENDING_ACCESS_TYPE
4527 {
4528     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_DISCARD = 0x0,
4529     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_PRESERVE = 0x1,
4530     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_RESOLVE = 0x2,
4531     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE_NO_ACCESS = 0x3,
4532 } D3D12_RENDER_PASS_ENDING_ACCESS_TYPE;
4533
4534 typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS
4535 {
4536     UINT SrcSubresource;
4537     UINT DstSubresource;
4538     UINT DstX;
4539     UINT DstY;
4540     D3D12_RECT SrcRect;
4541 } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS;
4542
4543 typedef struct D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS
4544 {
4545     ID3D12Resource *pSrcResource;
4546     ID3D12Resource *pDstResource;
4547     UINT SubresourceCount;
4548     const D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_SUBRESOURCE_PARAMETERS *pSubresourceParameters;
4549     DXGI_FORMAT Format;
4550     D3D12_RESOLVE_MODE ResolveMode;
4551     BOOL PreserveResolveSource;
4552 } D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS;
4553
4554 typedef struct D3D12_RENDER_PASS_ENDING_ACCESS
4555 {
4556     D3D12_RENDER_PASS_ENDING_ACCESS_TYPE Type;
4557     union
4558     {
4559         D3D12_RENDER_PASS_ENDING_ACCESS_RESOLVE_PARAMETERS Resolve;
4560     };
4561 } D3D12_RENDER_PASS_ENDING_ACCESS;
4562
4563 typedef struct D3D12_RENDER_PASS_RENDER_TARGET_DESC
4564 {
4565     D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
4566     D3D12_RENDER_PASS_BEGINNING_ACCESS BeginningAccess;
4567     D3D12_RENDER_PASS_ENDING_ACCESS EndingAccess;
4568 } D3D12_RENDER_PASS_RENDER_TARGET_DESC;
4569
4570 typedef struct D3D12_RENDER_PASS_DEPTH_STENCIL_DESC
4571 {
4572     D3D12_CPU_DESCRIPTOR_HANDLE cpuDescriptor;
4573     D3D12_RENDER_PASS_BEGINNING_ACCESS DepthBeginningAccess;
4574     D3D12_RENDER_PASS_BEGINNING_ACCESS StencilBeginningAccess;
4575     D3D12_RENDER_PASS_ENDING_ACCESS DepthEndingAccess;
4576     D3D12_RENDER_PASS_ENDING_ACCESS StencilEndingAccess;
4577 } D3D12_RENDER_PASS_DEPTH_STENCIL_DESC;
4578
4579 typedef enum D3D12_RENDER_PASS_FLAGS
4580 {
4581     D3D12_RENDER_PASS_FLAG_NONE = 0x0,
4582     D3D12_RENDER_PASS_FLAG_ALLOW_UAV_WRITES = 0x1,
4583     D3D12_RENDER_PASS_FLAG_SUSPENDING_PASS = 0x2,
4584     D3D12_RENDER_PASS_FLAG_RESUMING_PASS = 0x4
4585 } D3D12_RENDER_PASS_FLAGS;
4586 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_RENDER_PASS_FLAGS);")
4587
4588 [
4589     uuid(dbb84c27-36ce-4fc9-b801-f048c46ac570),
4590     object,
4591     local,
4592     pointer_default(unique)
4593 ]
4594 interface ID3D12MetaCommand : ID3D12Pageable
4595 {
4596     UINT64 GetRequiredParameterResourceSize(
4597             D3D12_META_COMMAND_PARAMETER_STAGE stage,
4598             UINT parameter_index);
4599 }
4600
4601 typedef struct D3D12_DISPATCH_RAYS_DESC
4602 {
4603     D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord;
4604     D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable;
4605     D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable;
4606     D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable;
4607     UINT Width;
4608     UINT Height;
4609     UINT Depth;
4610 } D3D12_DISPATCH_RAYS_DESC;
4611
4612 [
4613     uuid(8754318e-d3a9-4541-98cf-645b50dc4874),
4614     object,
4615     local,
4616     pointer_default(unique)
4617 ]
4618 interface ID3D12GraphicsCommandList4 : ID3D12GraphicsCommandList3
4619 {
4620     void BeginRenderPass(
4621             UINT render_targets_count,
4622             const D3D12_RENDER_PASS_RENDER_TARGET_DESC *render_targets,
4623             const D3D12_RENDER_PASS_DEPTH_STENCIL_DESC *depth_stencil,
4624             D3D12_RENDER_PASS_FLAGS flags);
4625
4626     void EndRenderPass();
4627
4628     void InitializeMetaCommand(
4629             ID3D12MetaCommand *meta_command,
4630             const void *initialization_parameters_data,
4631             SIZE_T initialization_parameters_data_size_in_bytes);
4632
4633     void ExecuteMetaCommand(
4634             ID3D12MetaCommand *meta_command,
4635             const void *execution_parameters_data,
4636             SIZE_T execution_parameters_data_size_in_bytes);
4637
4638     void BuildRaytracingAccelerationStructure(
4639             const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *desc,
4640             UINT postbuild_info_descs_count,
4641             const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *postbuild_info_descs);
4642
4643     void EmitRaytracingAccelerationStructurePostbuildInfo(
4644             const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC *desc,
4645             UINT src_acceleration_structures_count,
4646             const D3D12_GPU_VIRTUAL_ADDRESS *src_acceleration_structure_data);
4647
4648     void CopyRaytracingAccelerationStructure(
4649             D3D12_GPU_VIRTUAL_ADDRESS dst_acceleration_structure_data,
4650             D3D12_GPU_VIRTUAL_ADDRESS src_acceleration_structure_data,
4651             D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE mode);
4652
4653     void SetPipelineState1(ID3D12StateObject *state_object);
4654
4655     void DispatchRays(const D3D12_DISPATCH_RAYS_DESC *desc);
4656 }
4657
4658 typedef enum D3D12_SHADER_CACHE_MODE
4659 {
4660     D3D12_SHADER_CACHE_MODE_MEMORY = 0x0,
4661     D3D12_SHADER_CACHE_MODE_DISK = 0x1,
4662 } D3D12_SHADER_CACHE_MODE;
4663
4664 typedef enum D3D12_SHADER_CACHE_FLAGS
4665 {
4666     D3D12_SHADER_CACHE_FLAG_NONE = 0x0,
4667     D3D12_SHADER_CACHE_FLAG_DRIVER_VERSIONED = 0x1,
4668     D3D12_SHADER_CACHE_FLAG_USE_WORKING_DIR = 0x2,
4669 } D3D12_SHADER_CACHE_FLAGS;
4670 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_FLAGS);")
4671
4672 typedef struct D3D12_SHADER_CACHE_SESSION_DESC
4673 {
4674     GUID Identifier;
4675     D3D12_SHADER_CACHE_MODE Mode;
4676     D3D12_SHADER_CACHE_FLAGS Flags;
4677
4678     UINT MaximumInMemoryCacheSizeBytes;
4679     UINT MaximumInMemoryCacheEntries;
4680
4681     UINT MaximumValueFileSizeBytes;
4682
4683     UINT64 Version;
4684 } D3D12_SHADER_CACHE_SESSION_DESC;
4685
4686 typedef enum D3D12_BARRIER_LAYOUT
4687 {
4688     D3D12_BARRIER_LAYOUT_UNDEFINED = 0xffffffff,
4689     D3D12_BARRIER_LAYOUT_COMMON = 0x0,
4690     D3D12_BARRIER_LAYOUT_PRESENT = 0x0,
4691     D3D12_BARRIER_LAYOUT_GENERIC_READ = 0x1,
4692     D3D12_BARRIER_LAYOUT_RENDER_TARGET = 0x2,
4693     D3D12_BARRIER_LAYOUT_UNORDERED_ACCESS = 0x3,
4694     D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_WRITE = 0x4,
4695     D3D12_BARRIER_LAYOUT_DEPTH_STENCIL_READ = 0x5,
4696     D3D12_BARRIER_LAYOUT_SHADER_RESOURCE = 0x6,
4697     D3D12_BARRIER_LAYOUT_COPY_SOURCE = 0x7,
4698     D3D12_BARRIER_LAYOUT_COPY_DEST = 0x8,
4699     D3D12_BARRIER_LAYOUT_RESOLVE_SOURCE = 0x9,
4700     D3D12_BARRIER_LAYOUT_RESOLVE_DEST = 0xa,
4701     D3D12_BARRIER_LAYOUT_SHADING_RATE_SOURCE = 0xb,
4702     D3D12_BARRIER_LAYOUT_VIDEO_DECODE_READ = 0xc,
4703     D3D12_BARRIER_LAYOUT_VIDEO_DECODE_WRITE = 0xd,
4704     D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_READ = 0xe,
4705     D3D12_BARRIER_LAYOUT_VIDEO_PROCESS_WRITE = 0xf,
4706     D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_READ = 0x10,
4707     D3D12_BARRIER_LAYOUT_VIDEO_ENCODE_WRITE = 0x11,
4708     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COMMON = 0x12,
4709     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_GENERIC_READ = 0x13,
4710     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_UNORDERED_ACCESS = 0x14,
4711     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_SHADER_RESOURCE = 0x15,
4712     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_SOURCE = 0x16,
4713     D3D12_BARRIER_LAYOUT_DIRECT_QUEUE_COPY_DEST = 0x17,
4714     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COMMON = 0x18,
4715     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_GENERIC_READ = 0x19,
4716     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_UNORDERED_ACCESS = 0x1a,
4717     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_SHADER_RESOURCE = 0x1b,
4718     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_SOURCE = 0x1c,
4719     D3D12_BARRIER_LAYOUT_COMPUTE_QUEUE_COPY_DEST = 0x1d,
4720     D3D12_BARRIER_LAYOUT_VIDEO_QUEUE_COMMON = 0x1e,
4721 } D3D12_BARRIER_LAYOUT;
4722
4723 typedef enum D3D12_BARRIER_SYNC
4724 {
4725     D3D12_BARRIER_SYNC_NONE = 0x0,
4726     D3D12_BARRIER_SYNC_ALL = 0x1,
4727     D3D12_BARRIER_SYNC_DRAW = 0x2,
4728     D3D12_BARRIER_SYNC_INPUT_ASSEMBLER = 0x4,
4729     D3D12_BARRIER_SYNC_VERTEX_SHADING = 0x8,
4730     D3D12_BARRIER_SYNC_PIXEL_SHADING = 0x10,
4731     D3D12_BARRIER_SYNC_DEPTH_STENCIL = 0x20,
4732     D3D12_BARRIER_SYNC_RENDER_TARGET = 0x40,
4733     D3D12_BARRIER_SYNC_COMPUTE_SHADING = 0x80,
4734     D3D12_BARRIER_SYNC_RAYTRACING = 0x100,
4735     D3D12_BARRIER_SYNC_COPY = 0x200,
4736     D3D12_BARRIER_SYNC_RESOLVE = 0x400,
4737     D3D12_BARRIER_SYNC_EXECUTE_INDIRECT = 0x800,
4738     D3D12_BARRIER_SYNC_PREDICATION = 0x800,
4739     D3D12_BARRIER_SYNC_ALL_SHADING = 0x1000,
4740     D3D12_BARRIER_SYNC_NON_PIXEL_SHADING = 0x2000,
4741     D3D12_BARRIER_SYNC_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO = 0x4000,
4742     D3D12_BARRIER_SYNC_VIDEO_DECODE = 0x100000,
4743     D3D12_BARRIER_SYNC_VIDEO_PROCESS = 0x200000,
4744     D3D12_BARRIER_SYNC_VIDEO_ENCODE = 0x400000,
4745     D3D12_BARRIER_SYNC_BUILD_RAYTRACING_ACCELERATION_STRUCTURE = 0x800000,
4746     D3D12_BARRIER_SYNC_COPY_RAYTRACING_ACCELERATION_STRUCTURE = 0x1000000,
4747     D3D12_BARRIER_SYNC_SPLIT = 0x80000000,
4748 } D3D12_BARRIER_SYNC;
4749 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_SYNC);")
4750
4751 typedef enum D3D12_BARRIER_ACCESS
4752 {
4753     D3D12_BARRIER_ACCESS_COMMON = 0,
4754     D3D12_BARRIER_ACCESS_VERTEX_BUFFER = 0x1,
4755     D3D12_BARRIER_ACCESS_CONSTANT_BUFFER = 0x2,
4756     D3D12_BARRIER_ACCESS_INDEX_BUFFER = 0x4,
4757     D3D12_BARRIER_ACCESS_RENDER_TARGET = 0x8,
4758     D3D12_BARRIER_ACCESS_UNORDERED_ACCESS = 0x10,
4759     D3D12_BARRIER_ACCESS_DEPTH_STENCIL_WRITE = 0x20,
4760     D3D12_BARRIER_ACCESS_DEPTH_STENCIL_READ = 0x40,
4761     D3D12_BARRIER_ACCESS_SHADER_RESOURCE = 0x80,
4762     D3D12_BARRIER_ACCESS_STREAM_OUTPUT = 0x100,
4763     D3D12_BARRIER_ACCESS_INDIRECT_ARGUMENT = 0x200,
4764     D3D12_BARRIER_ACCESS_PREDICATION = 0x200,
4765     D3D12_BARRIER_ACCESS_COPY_DEST = 0x400,
4766     D3D12_BARRIER_ACCESS_COPY_SOURCE = 0x800,
4767     D3D12_BARRIER_ACCESS_RESOLVE_DEST = 0x1000,
4768     D3D12_BARRIER_ACCESS_RESOLVE_SOURCE = 0x2000,
4769     D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_READ = 0x4000,
4770     D3D12_BARRIER_ACCESS_RAYTRACING_ACCELERATION_STRUCTURE_WRITE = 0x8000,
4771     D3D12_BARRIER_ACCESS_SHADING_RATE_SOURCE = 0x10000,
4772     D3D12_BARRIER_ACCESS_VIDEO_DECODE_READ = 0x20000,
4773     D3D12_BARRIER_ACCESS_VIDEO_DECODE_WRITE = 0x40000,
4774     D3D12_BARRIER_ACCESS_VIDEO_PROCESS_READ = 0x80000,
4775     D3D12_BARRIER_ACCESS_VIDEO_PROCESS_WRITE = 0x100000,
4776     D3D12_BARRIER_ACCESS_VIDEO_ENCODE_READ = 0x200000,
4777     D3D12_BARRIER_ACCESS_VIDEO_ENCODE_WRITE = 0x400000,
4778     D3D12_BARRIER_ACCESS_NO_ACCESS = 0x80000000,
4779 } D3D12_BARRIER_ACCESS;
4780 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_BARRIER_ACCESS);")
4781
4782 typedef enum D3D12_BARRIER_TYPE
4783 {
4784     D3D12_BARRIER_TYPE_GLOBAL = 0x0,
4785     D3D12_BARRIER_TYPE_TEXTURE = 0x1,
4786     D3D12_BARRIER_TYPE_BUFFER = 0x2,
4787 } D3D12_BARRIER_TYPE;
4788
4789 typedef enum D3D12_TEXTURE_BARRIER_FLAGS
4790 {
4791     D3D12_TEXTURE_BARRIER_FLAG_NONE = 0x0,
4792     D3D12_TEXTURE_BARRIER_FLAG_DISCARD = 0x1,
4793 } D3D12_TEXTURE_BARRIER_FLAGS;
4794 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_TEXTURE_BARRIER_FLAGS);")
4795
4796 typedef struct D3D12_BARRIER_SUBRESOURCE_RANGE
4797 {
4798     UINT IndexOrFirstMipLevel;
4799     UINT NumMipLevels;
4800     UINT FirstArraySlice;
4801     UINT NumArraySlices;
4802     UINT FirstPlane;
4803     UINT NumPlanes;
4804 } D3D12_BARRIER_SUBRESOURCE_RANGE;
4805
4806 typedef struct D3D12_GLOBAL_BARRIER
4807 {
4808     D3D12_BARRIER_SYNC SyncBefore;
4809     D3D12_BARRIER_SYNC SyncAfter;
4810     D3D12_BARRIER_ACCESS AccessBefore;
4811     D3D12_BARRIER_ACCESS AccessAfter;
4812 } D3D12_GLOBAL_BARRIER;
4813
4814 typedef struct D3D12_TEXTURE_BARRIER
4815 {
4816     D3D12_BARRIER_SYNC SyncBefore;
4817     D3D12_BARRIER_SYNC SyncAfter;
4818     D3D12_BARRIER_ACCESS AccessBefore;
4819     D3D12_BARRIER_ACCESS AccessAfter;
4820     D3D12_BARRIER_LAYOUT LayoutBefore;
4821     D3D12_BARRIER_LAYOUT LayoutAfter;
4822     ID3D12Resource *pResource;
4823     D3D12_BARRIER_SUBRESOURCE_RANGE Subresources;
4824     D3D12_TEXTURE_BARRIER_FLAGS Flags;
4825 } D3D12_TEXTURE_BARRIER;
4826
4827 typedef struct D3D12_BUFFER_BARRIER
4828 {
4829     D3D12_BARRIER_SYNC SyncBefore;
4830     D3D12_BARRIER_SYNC SyncAfter;
4831     D3D12_BARRIER_ACCESS AccessBefore;
4832     D3D12_BARRIER_ACCESS AccessAfter;
4833     ID3D12Resource *pResource;
4834     UINT64 Offset;
4835     UINT64 Size;
4836 } D3D12_BUFFER_BARRIER;
4837
4838 typedef struct D3D12_BARRIER_GROUP
4839 {
4840     D3D12_BARRIER_TYPE Type;
4841     UINT32 NumBarriers;
4842     union
4843     {
4844         const D3D12_GLOBAL_BARRIER *pGlobalBarriers;
4845         const D3D12_TEXTURE_BARRIER *pTextureBarriers;
4846         const D3D12_BUFFER_BARRIER *pBufferBarriers;
4847     };
4848 } D3D12_BARRIER_GROUP;
4849
4850 [
4851     uuid(28e2495d-0f64-4ae4-a6ec-129255dc49a8),
4852     object,
4853     local,
4854     pointer_default(unique)
4855 ]
4856 interface ID3D12ShaderCacheSession : ID3D12DeviceChild
4857 {
4858     HRESULT FindValue(
4859             const void *key,
4860             UINT key_size,
4861             void *value,
4862             UINT *value_size);
4863     HRESULT StoreValue(
4864             const void *key,
4865             UINT key_size,
4866             const void *value,
4867             UINT value_size);
4868
4869     void SetDeleteOnDestroy();
4870     D3D12_SHADER_CACHE_SESSION_DESC GetDesc();
4871 }
4872
4873 typedef enum D3D12_SHADER_CACHE_KIND_FLAGS
4874 {
4875     D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CACHE_FOR_DRIVER = 0x1,
4876     D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_D3D_CONVERSIONS = 0x2,
4877     D3D12_SHADER_CACHE_KIND_FLAG_IMPLICIT_DRIVER_MANAGED = 0x4,
4878     D3D12_SHADER_CACHE_KIND_FLAG_APPLICATION_MANAGED = 0x8,
4879 } D3D12_SHADER_CACHE_KIND_FLAGS;
4880 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_KIND_FLAGS);")
4881
4882 typedef enum D3D12_SHADER_CACHE_CONTROL_FLAGS
4883 {
4884     D3D12_SHADER_CACHE_CONTROL_FLAG_DISABLE = 0x1,
4885     D3D12_SHADER_CACHE_CONTROL_FLAG_ENABLE = 0x2,
4886     D3D12_SHADER_CACHE_CONTROL_FLAG_CLEAR = 0x4,
4887 } D3D12_SHADER_CACHE_CONTROL_FLAGS;
4888 cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(D3D12_SHADER_CACHE_CONTROL_FLAGS);")
4889
4890 [
4891     uuid(4c80e962-f032-4f60-bc9e-ebc2cfa1d83c),
4892     object,
4893     local,
4894     pointer_default(unique)
4895 ]
4896 interface ID3D12Device9 : ID3D12Device8
4897 {
4898     HRESULT CreateShaderCacheSession(
4899             const D3D12_SHADER_CACHE_SESSION_DESC *desc,
4900             REFIID riid, void **session);
4901
4902     HRESULT ShaderCacheControl(
4903             D3D12_SHADER_CACHE_KIND_FLAGS kinds,
4904             D3D12_SHADER_CACHE_CONTROL_FLAGS control);
4905
4906     HRESULT CreateCommandQueue1(
4907             const D3D12_COMMAND_QUEUE_DESC *desc,
4908             REFIID creator_id,
4909             REFIID riid,
4910             void **command_queue);
4911 }
4912
4913 [
4914     uuid(517f8718-aa66-49f9-b02b-a7ab89c06031),
4915     object,
4916     local,
4917     pointer_default(unique)
4918 ]
4919 interface ID3D12Device10 : ID3D12Device9
4920 {
4921     HRESULT CreateCommittedResource3(
4922             const D3D12_HEAP_PROPERTIES *heap_properties,
4923             D3D12_HEAP_FLAGS heap_flags,
4924             const D3D12_RESOURCE_DESC1 *desc,
4925             D3D12_BARRIER_LAYOUT initial_layout,
4926             const D3D12_CLEAR_VALUE *optimized_clear_value,
4927             ID3D12ProtectedResourceSession *protected_session,
4928             UINT32 castable_formats_count,
4929             DXGI_FORMAT *castable_formats,
4930             REFIID riid_resource,
4931             void **resource);
4932
4933     HRESULT CreatePlacedResource2(
4934             ID3D12Heap *heap,
4935             UINT64 heap_offset,
4936             const D3D12_RESOURCE_DESC1 *desc,
4937             D3D12_BARRIER_LAYOUT initial_layout,
4938             const D3D12_CLEAR_VALUE *optimized_clear_value,
4939             UINT32 castable_formats_count,
4940             DXGI_FORMAT *castable_formats,
4941             REFIID riid,
4942             void **resource);
4943
4944     HRESULT CreateReservedResource2(
4945             const D3D12_RESOURCE_DESC *desc,
4946             D3D12_BARRIER_LAYOUT initial_layout,
4947             const D3D12_CLEAR_VALUE *optimized_clear_value,
4948             ID3D12ProtectedResourceSession *protected_session,
4949             UINT32 castable_formats_count,
4950             DXGI_FORMAT *castable_formats,
4951             REFIID riid,
4952             void **resource);
4953 }
4954
4955 [
4956     uuid(bc66d368-7373-4943-8757-fc87dc79e476),
4957     object,
4958     local,
4959     pointer_default(unique)
4960 ]
4961 interface ID3D12VirtualizationGuestDevice : IUnknown
4962 {
4963     HRESULT ShareWithHost(
4964             ID3D12DeviceChild *object,
4965             HANDLE *handle);
4966
4967     HRESULT CreateFenceFd(
4968             ID3D12Fence *fence,
4969             UINT64 fence_value,
4970             int *fence_fd);
4971 }
4972
4973 [
4974     uuid(7071e1f0-e84b-4b33-974f-12fa49de65c5),
4975     object,
4976     local,
4977     pointer_default(unique)
4978 ]
4979 interface ID3D12Tools : IUnknown
4980 {
4981     void EnableShaderInstrumentation(BOOL enable);
4982     BOOL ShaderInstrumentationEnabled();
4983 }
4984
4985 cpp_quote("DEFINE_GUID(CLSID_D3D12Debug,                     0xf2352aeb, 0xdd84, 0x49fe, 0xb9, 0x7b, 0xa9, 0xdc, 0xfd, 0xcc, 0x1b, 0x4f);")
4986 cpp_quote("DEFINE_GUID(CLSID_D3D12Tools,                     0xe38216b1, 0x3c8c, 0x4833, 0xaa, 0x09, 0x0a, 0x06, 0xb6, 0x5d, 0x96, 0xc8);")
4987 cpp_quote("DEFINE_GUID(CLSID_D3D12DeviceRemovedExtendedData, 0x4a75bbc4, 0x9ff4, 0x4ad8, 0x9f, 0x18, 0xab, 0xae, 0x84, 0xdc, 0x5f, 0xf2);")
4988 cpp_quote("DEFINE_GUID(CLSID_D3D12SDKConfiguration,          0x7cda6aca, 0xa03e, 0x49c8, 0x94, 0x58, 0x03, 0x34, 0xd2, 0x0e, 0x07, 0xce);")
4989
4990 [
4991     uuid(e9eb5314-33aa-42b2-a718-d77f58b1f1c7),
4992     object,
4993     local,
4994     pointer_default(unique)
4995 ]
4996 interface ID3D12SDKConfiguration : IUnknown
4997 {
4998     HRESULT SetSDKVersion(UINT version, const char *path);
4999 }
5000
5001 typedef enum D3D12_AXIS_SHADING_RATE
5002 {
5003     D3D12_AXIS_SHADING_RATE_1X = 0x0,
5004     D3D12_AXIS_SHADING_RATE_2X = 0x1,
5005     D3D12_AXIS_SHADING_RATE_4X = 0x2,
5006 } D3D12_AXIS_SHADING_RATE;
5007
5008 typedef enum D3D12_SHADING_RATE
5009 {
5010     D3D12_SHADING_RATE_1X1 = 0x0,
5011     D3D12_SHADING_RATE_1X2 = 0x1,
5012     D3D12_SHADING_RATE_2X1 = 0x4,
5013     D3D12_SHADING_RATE_2X2 = 0x5,
5014     D3D12_SHADING_RATE_2X4 = 0x6,
5015     D3D12_SHADING_RATE_4X2 = 0x9,
5016     D3D12_SHADING_RATE_4X4 = 0xa,
5017 } D3D12_SHADING_RATE;
5018
5019 typedef enum D3D12_SHADING_RATE_COMBINER
5020 {
5021     D3D12_SHADING_RATE_COMBINER_PASSTHROUGH = 0x0,
5022     D3D12_SHADING_RATE_COMBINER_OVERRIDE = 0x1,
5023     D3D12_SHADING_RATE_COMBINER_MIN = 0x2,
5024     D3D12_SHADING_RATE_COMBINER_MAX = 0x3,
5025     D3D12_SHADING_RATE_COMBINER_SUM = 0x4,
5026 } D3D12_SHADING_RATE_COMBINER;
5027
5028 [
5029     uuid(55050859-4024-474c-87f5-6472eaee44ea),
5030     object,
5031     local,
5032     pointer_default(unique)
5033 ]
5034 interface ID3D12GraphicsCommandList5 : ID3D12GraphicsCommandList4
5035 {
5036     void RSSetShadingRate(
5037             D3D12_SHADING_RATE base_shading_rate,
5038             const D3D12_SHADING_RATE_COMBINER *combiners);
5039
5040     void RSSetShadingRateImage(
5041             ID3D12Resource *shading_rate_image);
5042 }
5043
5044 const UINT D3D12_SHADING_RATE_X_AXIS_SHIFT = 2;
5045 const UINT D3D12_SHADING_RATE_VALID_MASK = 3;
5046
5047 cpp_quote("#define D3D12_MAKE_COARSE_SHADING_RATE(x, y) ((x) << D3D12_SHADING_RATE_X_AXIS_SHIFT | (y))")
5048 cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(val) (((val) >> D3D12_SHADING_RATE_X_AXIS_SHIFT) & D3D12_SHADING_RATE_VALID_MASK)")
5049 cpp_quote("#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(val) ((val) & D3D12_SHADING_RATE_VALID_MASK)")
5050
5051 typedef struct D3D12_DISPATCH_MESH_ARGUMENTS
5052 {
5053     UINT ThreadGroupCountX;
5054     UINT ThreadGroupCountY;
5055     UINT ThreadGroupCountZ;
5056 } D3D12_DISPATCH_MESH_ARGUMENTS;
5057
5058 [
5059     uuid(c3827890-e548-4cfa-96cf-5689a9370f80),
5060     object,
5061     local,
5062     pointer_default(unique)
5063 ]
5064 interface ID3D12GraphicsCommandList6 : ID3D12GraphicsCommandList5
5065 {
5066     void DispatchMesh(
5067             UINT thread_group_count_x,
5068             UINT thread_group_count_y,
5069             UINT thread_group_count_z);
5070 }
5071
5072 [
5073     uuid(dd171223-8b61-4769-90e3-160ccde4e2c1),
5074     object,
5075     local,
5076     pointer_default(unique)
5077 ]
5078 interface ID3D12GraphicsCommandList7 : ID3D12GraphicsCommandList6
5079 {
5080     void Barrier(
5081             UINT32 barrier_groups_count,
5082             const D3D12_BARRIER_GROUP *barrier_groups);
5083 };
5084
5085 typedef HRESULT (__stdcall *PFN_D3D12_CREATE_ROOT_SIGNATURE_DESERIALIZER)(
5086         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5087
5088 [local] HRESULT __stdcall D3D12CreateRootSignatureDeserializer(
5089         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5090
5091 typedef HRESULT (__stdcall *PFN_D3D12_CREATE_VERSIONED_ROOT_SIGNATURE_DESERIALIZER)(
5092         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5093
5094 [local] HRESULT __stdcall D3D12CreateVersionedRootSignatureDeserializer(
5095         const void *data, SIZE_T data_size, REFIID iid, void **deserializer);
5096
5097 typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_ROOT_SIGNATURE)(
5098         const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
5099         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
5100
5101 [local] HRESULT __stdcall D3D12SerializeRootSignature(
5102         const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
5103         D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob);
5104
5105 typedef HRESULT (__stdcall *PFN_D3D12_SERIALIZE_VERSIONED_ROOT_SIGNATURE)(
5106         const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob);
5107
5108 [local] HRESULT __stdcall D3D12SerializeVersionedRootSignature(
5109         const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *root_signature_desc,
5110         ID3DBlob **blob, ID3DBlob **error_blob);
5111
5112 typedef HRESULT (__stdcall *PFN_D3D12_CREATE_DEVICE)(IUnknown *adapter,
5113         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
5114
5115 [local] HRESULT __stdcall D3D12CreateDevice(IUnknown *adapter,
5116         D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device);
5117
5118 typedef HRESULT (__stdcall *PFN_D3D12_GET_DEBUG_INTERFACE)(REFIID iid, void **debug);
5119
5120 [local] HRESULT __stdcall D3D12GetDebugInterface(REFIID iid, void **debug);
5121
5122 [local] HRESULT __stdcall D3D12EnableExperimentalFeatures(UINT feature_count,
5123         const IID *iids, void *configurations, UINT *configurations_sizes);
5124
5125 cpp_quote("static const UUID D3D12ExperimentalShaderModels = { 0x76f5573e, 0xf13a, 0x40f5, { 0xb2, 0x97, 0x81, 0xce, 0x9e, 0x18, 0x93, 0x3f } };")
5126 cpp_quote("static const UUID D3D12TiledResourceTier4 = { 0xc9c4725f, 0xa81a, 0x4f56, { 0x8c, 0x5b, 0xc5, 0x10, 0x39, 0xd6, 0x94, 0xfb } };")
5127 cpp_quote("static const UUID D3D12MetaCommand = { 0xc734c97e, 0x8077, 0x48c8, { 0x9f, 0xdc, 0xd9, 0xd1, 0xdd, 0x31, 0xdd, 0x77 } };")
5128
5129 typedef HRESULT (__stdcall *PFN_D3D12_GET_INTERFACE)(REFCLSID clsid, REFIID iid, void **debug);
5130
5131 [local] HRESULT __stdcall D3D12GetInterface(REFCLSID clsid, REFIID iid, void **debug);