////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// D3D11 IDL
//
// Contains interface definitions for the D3D11 API.
//
// Copyright (C) Microsoft Corporation
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

import "oaidl.idl";
import "ocidl.idl";
import "dxgi.idl";
import "d3dcommon.idl";

// NOTE: The following constants are generated from the D3D11 hardware spec.  Do not edit these values directly.
cpp_quote( "#ifndef _D3D11_CONSTANTS" )
cpp_quote( "#define _D3D11_CONSTANTS" )
const UINT D3D11_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff;
const UINT D3D11_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff;
const UINT D3D11_8BIT_INDEX_STRIP_CUT_VALUE = 0xff;
const UINT D3D11_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9;
const UINT D3D11_CLIP_OR_CULL_DISTANCE_COUNT = 8;
const UINT D3D11_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_PARTIAL_UPDATE_EXTENTS_BYTE_ALIGNMENT = 16;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1;
const UINT D3D11_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1;
const UINT D3D11_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64;
const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4;
const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1;
const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1;
const UINT D3D11_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1;
const UINT D3D11_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1;
const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128;
const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1;
const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1;
const UINT D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128;
const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1;
const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16;
const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1;
const UINT D3D11_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1;
const UINT D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT = 16;
const UINT D3D11_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32;
const UINT D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4;
const UINT D3D11_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_COMMONSHADER_TEMP_REGISTER_COUNT = 4096;
const UINT D3D11_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3;
const UINT D3D11_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3;
const UINT D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10;
const INT D3D11_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10;
const INT D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8;
const UINT D3D11_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7;
const UINT D3D11_CS_4_X_BUCKET00_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 256;
const UINT D3D11_CS_4_X_BUCKET00_MAX_NUM_THREADS_PER_GROUP = 64;
const UINT D3D11_CS_4_X_BUCKET01_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 240;
const UINT D3D11_CS_4_X_BUCKET01_MAX_NUM_THREADS_PER_GROUP = 68;
const UINT D3D11_CS_4_X_BUCKET02_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 224;
const UINT D3D11_CS_4_X_BUCKET02_MAX_NUM_THREADS_PER_GROUP = 72;
const UINT D3D11_CS_4_X_BUCKET03_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 208;
const UINT D3D11_CS_4_X_BUCKET03_MAX_NUM_THREADS_PER_GROUP = 76;
const UINT D3D11_CS_4_X_BUCKET04_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 192;
const UINT D3D11_CS_4_X_BUCKET04_MAX_NUM_THREADS_PER_GROUP = 84;
const UINT D3D11_CS_4_X_BUCKET05_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 176;
const UINT D3D11_CS_4_X_BUCKET05_MAX_NUM_THREADS_PER_GROUP = 92;
const UINT D3D11_CS_4_X_BUCKET06_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 160;
const UINT D3D11_CS_4_X_BUCKET06_MAX_NUM_THREADS_PER_GROUP = 100;
const UINT D3D11_CS_4_X_BUCKET07_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 144;
const UINT D3D11_CS_4_X_BUCKET07_MAX_NUM_THREADS_PER_GROUP = 112;
const UINT D3D11_CS_4_X_BUCKET08_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 128;
const UINT D3D11_CS_4_X_BUCKET08_MAX_NUM_THREADS_PER_GROUP = 128;
const UINT D3D11_CS_4_X_BUCKET09_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 112;
const UINT D3D11_CS_4_X_BUCKET09_MAX_NUM_THREADS_PER_GROUP = 144;
const UINT D3D11_CS_4_X_BUCKET10_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 96;
const UINT D3D11_CS_4_X_BUCKET10_MAX_NUM_THREADS_PER_GROUP = 168;
const UINT D3D11_CS_4_X_BUCKET11_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 80;
const UINT D3D11_CS_4_X_BUCKET11_MAX_NUM_THREADS_PER_GROUP = 204;
const UINT D3D11_CS_4_X_BUCKET12_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 64;
const UINT D3D11_CS_4_X_BUCKET12_MAX_NUM_THREADS_PER_GROUP = 256;
const UINT D3D11_CS_4_X_BUCKET13_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 48;
const UINT D3D11_CS_4_X_BUCKET13_MAX_NUM_THREADS_PER_GROUP = 340;
const UINT D3D11_CS_4_X_BUCKET14_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 32;
const UINT D3D11_CS_4_X_BUCKET14_MAX_NUM_THREADS_PER_GROUP = 512;
const UINT D3D11_CS_4_X_BUCKET15_MAX_BYTES_TGSM_WRITABLE_PER_THREAD = 16;
const UINT D3D11_CS_4_X_BUCKET15_MAX_NUM_THREADS_PER_GROUP = 768;
const UINT D3D11_CS_4_X_DISPATCH_MAX_THREAD_GROUPS_IN_Z_DIMENSION = 1;
const UINT D3D11_CS_4_X_RAW_UAV_BYTE_ALIGNMENT = 256;
const UINT D3D11_CS_4_X_THREAD_GROUP_MAX_THREADS_PER_GROUP = 768;
const UINT D3D11_CS_4_X_THREAD_GROUP_MAX_X = 768;
const UINT D3D11_CS_4_X_THREAD_GROUP_MAX_Y = 768;
const UINT D3D11_CS_4_X_UAV_REGISTER_COUNT = 1;
const UINT D3D11_CS_DISPATCH_MAX_THREAD_GROUPS_PER_DIMENSION = 65535;
const UINT D3D11_CS_TGSM_REGISTER_COUNT = 8192;
const UINT D3D11_CS_TGSM_REGISTER_READS_PER_INST = 1;
const UINT D3D11_CS_TGSM_RESOURCE_REGISTER_COMPONENTS = 1;
const UINT D3D11_CS_TGSM_RESOURCE_REGISTER_READ_PORTS = 1;
const UINT D3D11_CS_THREADGROUPID_REGISTER_COMPONENTS = 3;
const UINT D3D11_CS_THREADGROUPID_REGISTER_COUNT = 1;
const UINT D3D11_CS_THREADIDINGROUPFLATTENED_REGISTER_COMPONENTS = 1;
const UINT D3D11_CS_THREADIDINGROUPFLATTENED_REGISTER_COUNT = 1;
const UINT D3D11_CS_THREADIDINGROUP_REGISTER_COMPONENTS = 3;
const UINT D3D11_CS_THREADIDINGROUP_REGISTER_COUNT = 1;
const UINT D3D11_CS_THREADID_REGISTER_COMPONENTS = 3;
const UINT D3D11_CS_THREADID_REGISTER_COUNT = 1;
const UINT D3D11_CS_THREAD_GROUP_MAX_THREADS_PER_GROUP = 1024;
const UINT D3D11_CS_THREAD_GROUP_MAX_X = 1024;
const UINT D3D11_CS_THREAD_GROUP_MAX_Y = 1024;
const UINT D3D11_CS_THREAD_GROUP_MAX_Z = 64;
const UINT D3D11_CS_THREAD_GROUP_MIN_X = 1;
const UINT D3D11_CS_THREAD_GROUP_MIN_Y = 1;
const UINT D3D11_CS_THREAD_GROUP_MIN_Z = 1;
const UINT D3D11_CS_THREAD_LOCAL_TEMP_REGISTER_POOL = 16384;
cpp_quote( "#define D3D11_DEFAULT_BLEND_FACTOR_ALPHA	( 1.0f )" )
cpp_quote( "#define D3D11_DEFAULT_BLEND_FACTOR_BLUE	( 1.0f )" )
cpp_quote( "#define D3D11_DEFAULT_BLEND_FACTOR_GREEN	( 1.0f )" )
cpp_quote( "#define D3D11_DEFAULT_BLEND_FACTOR_RED	( 1.0f )" )
cpp_quote( "#define D3D11_DEFAULT_BORDER_COLOR_COMPONENT	( 0.0f )" )
const UINT D3D11_DEFAULT_DEPTH_BIAS = 0;
cpp_quote( "#define D3D11_DEFAULT_DEPTH_BIAS_CLAMP	( 0.0f )" )
const UINT D3D11_DEFAULT_MAX_ANISOTROPY = 16;
cpp_quote( "#define D3D11_DEFAULT_MIP_LOD_BIAS	( 0.0f )" )
const UINT D3D11_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0;
const UINT D3D11_DEFAULT_SAMPLE_MASK = 0xffffffff;
const UINT D3D11_DEFAULT_SCISSOR_ENDX = 0;
const UINT D3D11_DEFAULT_SCISSOR_ENDY = 0;
const UINT D3D11_DEFAULT_SCISSOR_STARTX = 0;
const UINT D3D11_DEFAULT_SCISSOR_STARTY = 0;
cpp_quote( "#define D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS	( 0.0f )" )
const UINT D3D11_DEFAULT_STENCIL_READ_MASK = 0xff;
const UINT D3D11_DEFAULT_STENCIL_REFERENCE = 0;
const UINT D3D11_DEFAULT_STENCIL_WRITE_MASK = 0xff;
const UINT D3D11_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0;
const UINT D3D11_DEFAULT_VIEWPORT_HEIGHT = 0;
cpp_quote( "#define D3D11_DEFAULT_VIEWPORT_MAX_DEPTH	( 0.0f )" )
cpp_quote( "#define D3D11_DEFAULT_VIEWPORT_MIN_DEPTH	( 0.0f )" )
const UINT D3D11_DEFAULT_VIEWPORT_TOPLEFTX = 0;
const UINT D3D11_DEFAULT_VIEWPORT_TOPLEFTY = 0;
const UINT D3D11_DEFAULT_VIEWPORT_WIDTH = 0;
const UINT D3D11_DS_INPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968;
const UINT D3D11_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENTS = 4;
const UINT D3D11_DS_INPUT_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_DS_INPUT_CONTROL_POINT_REGISTER_COUNT = 32;
const UINT D3D11_DS_INPUT_CONTROL_POINT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_DS_INPUT_CONTROL_POINT_REGISTER_READ_PORTS = 1;
const UINT D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENTS = 3;
const UINT D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_COUNT = 1;
const UINT D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_DS_INPUT_DOMAIN_POINT_REGISTER_READ_PORTS = 1;
const UINT D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4;
const UINT D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_COUNT = 32;
const UINT D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_DS_INPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1;
const UINT D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1;
const UINT D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1;
const UINT D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2;
const UINT D3D11_DS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1;
const UINT D3D11_DS_OUTPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_DS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_DS_OUTPUT_REGISTER_COUNT = 32;
cpp_quote( "#define D3D11_FLOAT16_FUSED_TOLERANCE_IN_ULP	( 0.6 )" )
cpp_quote( "#define D3D11_FLOAT32_MAX	( 3.402823466e+38f )" )
cpp_quote( "#define D3D11_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP	( 0.6f )" )
cpp_quote( "#define D3D11_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR	( 2.4f )" )
cpp_quote( "#define D3D11_FLOAT_TO_SRGB_EXPONENT_NUMERATOR	( 1.0f )" )
cpp_quote( "#define D3D11_FLOAT_TO_SRGB_OFFSET	( 0.055f )" )
cpp_quote( "#define D3D11_FLOAT_TO_SRGB_SCALE_1	( 12.92f )" )
cpp_quote( "#define D3D11_FLOAT_TO_SRGB_SCALE_2	( 1.055f )" )
cpp_quote( "#define D3D11_FLOAT_TO_SRGB_THRESHOLD	( 0.0031308f )" )
cpp_quote( "#define D3D11_FTOI_INSTRUCTION_MAX_INPUT	( 2147483647.999f )" )
cpp_quote( "#define D3D11_FTOI_INSTRUCTION_MIN_INPUT	( -2147483648.999f )" )
cpp_quote( "#define D3D11_FTOU_INSTRUCTION_MAX_INPUT	( 4294967295.999f )" )
cpp_quote( "#define D3D11_FTOU_INSTRUCTION_MIN_INPUT	( 0.0f )" )
const UINT D3D11_GS_INPUT_INSTANCE_ID_READS_PER_INST = 2;
const UINT D3D11_GS_INPUT_INSTANCE_ID_READ_PORTS = 1;
const UINT D3D11_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENTS = 1;
const UINT D3D11_GS_INPUT_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_GS_INPUT_INSTANCE_ID_REGISTER_COUNT = 1;
const UINT D3D11_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1;
const UINT D3D11_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1;
const UINT D3D11_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2;
const UINT D3D11_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1;
const UINT D3D11_GS_INPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_GS_INPUT_REGISTER_COUNT = 32;
const UINT D3D11_GS_INPUT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_GS_INPUT_REGISTER_READ_PORTS = 1;
const UINT D3D11_GS_INPUT_REGISTER_VERTICES = 32;
const UINT D3D11_GS_MAX_INSTANCE_COUNT = 32;
const UINT D3D11_GS_MAX_OUTPUT_VERTEX_COUNT_ACROSS_INSTANCES = 1024;
const UINT D3D11_GS_OUTPUT_ELEMENTS = 32;
const UINT D3D11_GS_OUTPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_GS_OUTPUT_REGISTER_COUNT = 32;
const UINT D3D11_HS_CONTROL_POINT_PHASE_INPUT_REGISTER_COUNT = 32;
const UINT D3D11_HS_CONTROL_POINT_PHASE_OUTPUT_REGISTER_COUNT = 32;
const UINT D3D11_HS_CONTROL_POINT_REGISTER_COMPONENTS = 4;
const UINT D3D11_HS_CONTROL_POINT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_HS_CONTROL_POINT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_HS_CONTROL_POINT_REGISTER_READ_PORTS = 1;
const UINT D3D11_HS_FORK_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xFFFFFFFF;
const UINT D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENTS = 1;
const UINT D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_COUNT = 1;
const UINT D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READS_PER_INST = 2;
const UINT D3D11_HS_INPUT_FORK_INSTANCE_ID_REGISTER_READ_PORTS = 1;
const UINT D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENTS = 1;
const UINT D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_COUNT = 1;
const UINT D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READS_PER_INST = 2;
const UINT D3D11_HS_INPUT_JOIN_INSTANCE_ID_REGISTER_READ_PORTS = 1;
const UINT D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENTS = 1;
const UINT D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_COUNT = 1;
const UINT D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_READS_PER_INST = 2;
const UINT D3D11_HS_INPUT_PRIMITIVE_ID_REGISTER_READ_PORTS = 1;
const UINT D3D11_HS_JOIN_PHASE_INSTANCE_COUNT_UPPER_BOUND = 0xFFFFFFFF;
cpp_quote( "#define D3D11_HS_MAXTESSFACTOR_LOWER_BOUND	( 1.0f )" )
cpp_quote( "#define D3D11_HS_MAXTESSFACTOR_UPPER_BOUND	( 64.0f )" )
const UINT D3D11_HS_OUTPUT_CONTROL_POINTS_MAX_TOTAL_SCALARS = 3968;
const UINT D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENTS = 1;
const UINT D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_COUNT = 1;
const UINT D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READS_PER_INST = 2;
const UINT D3D11_HS_OUTPUT_CONTROL_POINT_ID_REGISTER_READ_PORTS = 1;
const UINT D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENTS = 4;
const UINT D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_COUNT = 32;
const UINT D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_READ_PORTS = 1;
const UINT D3D11_HS_OUTPUT_PATCH_CONSTANT_REGISTER_SCALAR_COMPONENTS = 128;
const UINT D3D11_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0;
const UINT D3D11_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0;
const UINT D3D11_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0;
const UINT D3D11_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1;
const UINT D3D11_IA_INSTANCE_ID_BIT_COUNT = 32;
const UINT D3D11_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32;
const UINT D3D11_IA_PATCH_MAX_CONTROL_POINT_COUNT = 32;
const UINT D3D11_IA_PRIMITIVE_ID_BIT_COUNT = 32;
const UINT D3D11_IA_VERTEX_ID_BIT_COUNT = 32;
const UINT D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 32;
const UINT D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 128;
const UINT D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 32;
const UINT D3D11_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff;
const UINT D3D11_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff;
const UINT D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 0xffffffff;
const UINT D3D11_KEEP_UNORDERED_ACCESS_VIEWS = 0xffffffff;
cpp_quote( "#define D3D11_LINEAR_GAMMA	( 1.0f )" )
const UINT D3D11_MAJOR_VERSION = 11;
cpp_quote( "#define D3D11_MAX_BORDER_COLOR_COMPONENT	( 1.0f )" )
cpp_quote( "#define D3D11_MAX_DEPTH	( 1.0f )" )
const UINT D3D11_MAX_MAXANISOTROPY = 16;
const UINT D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT = 32;
cpp_quote( "#define D3D11_MAX_POSITION_VALUE	( 3.402823466e+34f )" )
const UINT D3D11_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17;
const UINT D3D11_MINOR_VERSION = 0;
cpp_quote( "#define D3D11_MIN_BORDER_COLOR_COMPONENT	( 0.0f )" )
cpp_quote( "#define D3D11_MIN_DEPTH	( 0.0f )" )
const UINT D3D11_MIN_MAXANISOTROPY = 0;
cpp_quote( "#define D3D11_MIP_LOD_BIAS_MAX	( 15.99f )" )
cpp_quote( "#define D3D11_MIP_LOD_BIAS_MIN	( -16.0f )" )
const UINT D3D11_MIP_LOD_FRACTIONAL_BIT_COUNT = 8;
const UINT D3D11_MIP_LOD_RANGE_BIT_COUNT = 8;
cpp_quote( "#define D3D11_MULTISAMPLE_ANTIALIAS_LINE_WIDTH	( 1.4f )" )
const UINT D3D11_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0;
const UINT D3D11_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15;
const UINT D3D11_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 16;
const UINT D3D11_PS_CS_UAV_REGISTER_COMPONENTS = 1;
const UINT D3D11_PS_CS_UAV_REGISTER_COUNT = 8;
const UINT D3D11_PS_CS_UAV_REGISTER_READS_PER_INST = 1;
const UINT D3D11_PS_CS_UAV_REGISTER_READ_PORTS = 1;
const UINT D3D11_PS_FRONTFACING_DEFAULT_VALUE = 0xFFFFFFFF;
const UINT D3D11_PS_FRONTFACING_FALSE_VALUE = 0x00000000;
const UINT D3D11_PS_FRONTFACING_TRUE_VALUE = 0xFFFFFFFF;
const UINT D3D11_PS_INPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_PS_INPUT_REGISTER_COUNT = 32;
const UINT D3D11_PS_INPUT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_PS_INPUT_REGISTER_READ_PORTS = 1;
cpp_quote( "#define D3D11_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT	( 0.0f )" )
const UINT D3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1;
const UINT D3D11_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1;
const UINT D3D11_PS_OUTPUT_MASK_REGISTER_COMPONENTS = 1;
const UINT D3D11_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_PS_OUTPUT_MASK_REGISTER_COUNT = 1;
const UINT D3D11_PS_OUTPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_PS_OUTPUT_REGISTER_COUNT = 8;
cpp_quote( "#define D3D11_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT	( 0.5f )" )
const UINT D3D11_RAW_UAV_SRV_BYTE_ALIGNMENT = 16;
const UINT D3D11_REQ_BLEND_OBJECT_COUNT_PER_DEVICE = 4096;
const UINT D3D11_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27;
const UINT D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096;
const UINT D3D11_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_DEVICE = 4096;
const UINT D3D11_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32;
const UINT D3D11_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32;
const UINT D3D11_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 16384;
const UINT D3D11_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024;
const UINT D3D11_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096;
const UINT D3D11_REQ_MAXANISOTROPY = 16;
const UINT D3D11_REQ_MIP_LEVELS = 15;
const UINT D3D11_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048;
const UINT D3D11_REQ_RASTERIZER_OBJECT_COUNT_PER_DEVICE = 4096;
const UINT D3D11_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 16384;
const UINT D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_A_TERM = 128;
cpp_quote( "#define D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_B_TERM	( 0.25f )" )
const UINT D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM = 2048;
const UINT D3D11_REQ_RESOURCE_VIEW_COUNT_PER_DEVICE_2_TO_EXP = 20;
const UINT D3D11_REQ_SAMPLER_OBJECT_COUNT_PER_DEVICE = 4096;
const UINT D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 2048;
const UINT D3D11_REQ_TEXTURE1D_U_DIMENSION = 16384;
const UINT D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 2048;
const UINT D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384;
const UINT D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048;
const UINT D3D11_REQ_TEXTURECUBE_DIMENSION = 16384;
const UINT D3D11_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0;
const UINT D3D11_SHADER_MAJOR_VERSION = 5;
const UINT D3D11_SHADER_MAX_INSTANCES = 65535;
const UINT D3D11_SHADER_MAX_INTERFACES = 253;
const UINT D3D11_SHADER_MAX_INTERFACE_CALL_SITES = 4096;
const UINT D3D11_SHADER_MAX_TYPES = 65535;
const UINT D3D11_SHADER_MINOR_VERSION = 0;
const UINT D3D11_SHIFT_INSTRUCTION_PAD_VALUE = 0;
const UINT D3D11_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5;
const UINT D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT = 8;
const UINT D3D11_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048;
const UINT D3D11_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 512;
const UINT D3D11_SO_BUFFER_SLOT_COUNT = 4;
const UINT D3D11_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff;
const UINT D3D11_SO_NO_RASTERIZED_STREAM = 0xffffffff;
const UINT D3D11_SO_OUTPUT_COMPONENT_COUNT = 128;
const UINT D3D11_SO_STREAM_COUNT = 4;
const UINT D3D11_SPEC_DATE_DAY = 16;
const UINT D3D11_SPEC_DATE_MONTH = 05;
const UINT D3D11_SPEC_DATE_YEAR = 2011;
cpp_quote( "#define D3D11_SPEC_VERSION	( 1.07 )" )
cpp_quote( "#define D3D11_SRGB_GAMMA	( 2.2f )" )
cpp_quote( "#define D3D11_SRGB_TO_FLOAT_DENOMINATOR_1	( 12.92f )" )
cpp_quote( "#define D3D11_SRGB_TO_FLOAT_DENOMINATOR_2	( 1.055f )" )
cpp_quote( "#define D3D11_SRGB_TO_FLOAT_EXPONENT	( 2.4f )" )
cpp_quote( "#define D3D11_SRGB_TO_FLOAT_OFFSET	( 0.055f )" )
cpp_quote( "#define D3D11_SRGB_TO_FLOAT_THRESHOLD	( 0.04045f )" )
cpp_quote( "#define D3D11_SRGB_TO_FLOAT_TOLERANCE_IN_ULP	( 0.5f )" )
const UINT D3D11_STANDARD_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64;
const UINT D3D11_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4;
const UINT D3D11_STANDARD_PIXEL_COMPONENT_COUNT = 128;
const UINT D3D11_STANDARD_PIXEL_ELEMENT_COUNT = 32;
const UINT D3D11_STANDARD_VECTOR_SIZE = 4;
const UINT D3D11_STANDARD_VERTEX_ELEMENT_COUNT = 32;
const UINT D3D11_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64;
const UINT D3D11_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8;
const UINT D3D11_SUBTEXEL_FRACTIONAL_BIT_COUNT = 8;
const UINT D3D11_TESSELLATOR_MAX_EVEN_TESSELLATION_FACTOR = 64;
const UINT D3D11_TESSELLATOR_MAX_ISOLINE_DENSITY_TESSELLATION_FACTOR = 64;
const UINT D3D11_TESSELLATOR_MAX_ODD_TESSELLATION_FACTOR = 63;
const UINT D3D11_TESSELLATOR_MAX_TESSELLATION_FACTOR = 64;
const UINT D3D11_TESSELLATOR_MIN_EVEN_TESSELLATION_FACTOR = 2;
const UINT D3D11_TESSELLATOR_MIN_ISOLINE_DENSITY_TESSELLATION_FACTOR = 1;
const UINT D3D11_TESSELLATOR_MIN_ODD_TESSELLATION_FACTOR = 1;
const UINT D3D11_TEXEL_ADDRESS_RANGE_BIT_COUNT = 16;
const UINT D3D11_UNBOUND_MEMORY_ACCESS_RESULT = 0;
const UINT D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15;
const UINT D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16;
const UINT D3D11_VIEWPORT_BOUNDS_MAX = 32767;
const INT D3D11_VIEWPORT_BOUNDS_MIN = -32768;
const UINT D3D11_VS_INPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_VS_INPUT_REGISTER_COUNT = 32;
const UINT D3D11_VS_INPUT_REGISTER_READS_PER_INST = 2;
const UINT D3D11_VS_INPUT_REGISTER_READ_PORTS = 1;
const UINT D3D11_VS_OUTPUT_REGISTER_COMPONENTS = 4;
const UINT D3D11_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32;
const UINT D3D11_VS_OUTPUT_REGISTER_COUNT = 32;
const UINT D3D11_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10;
const UINT D3D11_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25;
const UINT D3D11_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25;
cpp_quote( "#endif" )
cpp_quote( "#ifndef _D3D11_1_CONSTANTS" )
cpp_quote( "#define _D3D11_1_CONSTANTS" )
const UINT D3D11_1_UAV_SLOT_COUNT = 64;
cpp_quote( "#endif" )
cpp_quote( "#ifndef _D3D11_2_CONSTANTS" )
cpp_quote( "#define _D3D11_2_CONSTANTS" )
const UINT D3D11_2_TILED_RESOURCE_TILE_SIZE_IN_BYTES = 65536;
cpp_quote( "#endif" )


const UINT _FACD3D11 = 0x87c;
const UINT _FACD3D11DEBUG = _FACD3D11 + 1;

cpp_quote( "/* Direct3D errors are now found in winerror.h */" )
cpp_quote( "#define MAKE_D3D11_HRESULT( code )  MAKE_HRESULT( 1, _FACD3D11, code )" )
cpp_quote( "#define MAKE_D3D11_STATUS( code )    MAKE_HRESULT( 0, _FACD3D11, code )" )

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_DEFAULT {};" )
cpp_quote( "extern const DECLSPEC_SELECTANY CD3D11_DEFAULT D3D11_DEFAULT;" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

typedef enum D3D11_INPUT_CLASSIFICATION
{
    D3D11_INPUT_PER_VERTEX_DATA = 0,
    D3D11_INPUT_PER_INSTANCE_DATA = 1
} D3D11_INPUT_CLASSIFICATION;

const UINT D3D11_APPEND_ALIGNED_ELEMENT = 0xffffffff;

typedef struct D3D11_INPUT_ELEMENT_DESC
{
    LPCSTR SemanticName;
    UINT SemanticIndex;
    DXGI_FORMAT Format;
    UINT InputSlot;
    UINT AlignedByteOffset;
    D3D11_INPUT_CLASSIFICATION InputSlotClass;
    UINT InstanceDataStepRate;
} D3D11_INPUT_ELEMENT_DESC;

// Keep FILL_MODE values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D11_FILL_MODE
{
    // 1 was POINT in D3D, unused in D3D11
    D3D11_FILL_WIREFRAME = 2,
    D3D11_FILL_SOLID = 3
} D3D11_FILL_MODE;

typedef D3D_PRIMITIVE_TOPOLOGY D3D11_PRIMITIVE_TOPOLOGY;

typedef D3D_PRIMITIVE D3D11_PRIMITIVE;

// Keep CULL_MODE values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D11_CULL_MODE
{
    D3D11_CULL_NONE = 1,
    D3D11_CULL_FRONT = 2,
    D3D11_CULL_BACK = 3
} D3D11_CULL_MODE;

typedef struct D3D11_SO_DECLARATION_ENTRY
{
    UINT Stream;
    LPCSTR SemanticName;
    UINT SemanticIndex;
    BYTE StartComponent;
    BYTE ComponentCount;
    BYTE OutputSlot;
} D3D11_SO_DECLARATION_ENTRY;

typedef struct D3D11_VIEWPORT
{
    FLOAT TopLeftX;
    FLOAT TopLeftY;
    FLOAT Width;
    FLOAT Height;
    FLOAT MinDepth;
    FLOAT MaxDepth;
} D3D11_VIEWPORT;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "inline bool operator==( const D3D11_VIEWPORT& l, const D3D11_VIEWPORT& r )" )
cpp_quote( "{" )
cpp_quote( "    return l.TopLeftX == r.TopLeftX && l.TopLeftY == r.TopLeftY && l.Width == r.Width &&" )
cpp_quote( "        l.Height == r.Height && l.MinDepth == r.MinDepth && l.MaxDepth == r.MaxDepth;" )
cpp_quote( "}" )
cpp_quote( "inline bool operator!=( const D3D11_VIEWPORT& l, const D3D11_VIEWPORT& r )" )
cpp_quote( "{ return !( l == r ); }" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

typedef struct D3D11_DRAW_INSTANCED_INDIRECT_ARGS 
{ 
    UINT VertexCountPerInstance; 
    UINT InstanceCount; 
    UINT StartVertexLocation; 
    UINT StartInstanceLocation; 
} D3D11_DRAW_INSTANCED_INDIRECT_ARGS; 

typedef struct D3D11_DRAW_INDEXED_INSTANCED_INDIRECT_ARGS 
{ 
    UINT IndexCountPerInstance; 
    UINT InstanceCount; 
    UINT StartIndexLocation; 
    INT BaseVertexLocation; 
    UINT StartInstanceLocation; 
} D3D11_DRAW_INDEXED_INSTANCED_INDIRECT_ARGS; 

typedef enum D3D11_RESOURCE_DIMENSION
{
    D3D11_RESOURCE_DIMENSION_UNKNOWN = 0,
    D3D11_RESOURCE_DIMENSION_BUFFER = 1,
    D3D11_RESOURCE_DIMENSION_TEXTURE1D = 2,
    D3D11_RESOURCE_DIMENSION_TEXTURE2D = 3,
    D3D11_RESOURCE_DIMENSION_TEXTURE3D = 4,
} D3D11_RESOURCE_DIMENSION;

typedef D3D_SRV_DIMENSION D3D11_SRV_DIMENSION;

typedef enum D3D11_DSV_DIMENSION
{
    D3D11_DSV_DIMENSION_UNKNOWN = 0,
    D3D11_DSV_DIMENSION_TEXTURE1D = 1,
    D3D11_DSV_DIMENSION_TEXTURE1DARRAY = 2,
    D3D11_DSV_DIMENSION_TEXTURE2D = 3,
    D3D11_DSV_DIMENSION_TEXTURE2DARRAY = 4,
    D3D11_DSV_DIMENSION_TEXTURE2DMS = 5,
    D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY = 6,
} D3D11_DSV_DIMENSION;

typedef enum D3D11_RTV_DIMENSION
{
    D3D11_RTV_DIMENSION_UNKNOWN = 0,
    D3D11_RTV_DIMENSION_BUFFER = 1,
    D3D11_RTV_DIMENSION_TEXTURE1D = 2,
    D3D11_RTV_DIMENSION_TEXTURE1DARRAY = 3,
    D3D11_RTV_DIMENSION_TEXTURE2D = 4,
    D3D11_RTV_DIMENSION_TEXTURE2DARRAY = 5,
    D3D11_RTV_DIMENSION_TEXTURE2DMS = 6,
    D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY = 7,
    D3D11_RTV_DIMENSION_TEXTURE3D = 8,
} D3D11_RTV_DIMENSION;

typedef enum D3D11_UAV_DIMENSION
{
    D3D11_UAV_DIMENSION_UNKNOWN = 0,
    D3D11_UAV_DIMENSION_BUFFER = 1,
    D3D11_UAV_DIMENSION_TEXTURE1D = 2,
    D3D11_UAV_DIMENSION_TEXTURE1DARRAY = 3,
    D3D11_UAV_DIMENSION_TEXTURE2D = 4,
    D3D11_UAV_DIMENSION_TEXTURE2DARRAY = 5,
    D3D11_UAV_DIMENSION_TEXTURE3D = 8,
} D3D11_UAV_DIMENSION;
 
typedef enum D3D11_USAGE
{
    D3D11_USAGE_DEFAULT = 0,
    D3D11_USAGE_IMMUTABLE = 1,
    D3D11_USAGE_DYNAMIC = 2,
    D3D11_USAGE_STAGING = 3,
} D3D11_USAGE;

typedef enum D3D11_BIND_FLAG
{
    D3D11_BIND_VERTEX_BUFFER = 0x00000001L,
    D3D11_BIND_INDEX_BUFFER = 0x00000002L,
    D3D11_BIND_CONSTANT_BUFFER = 0x00000004L,
    D3D11_BIND_SHADER_RESOURCE = 0x00000008L,
    D3D11_BIND_STREAM_OUTPUT = 0x00000010L,
    D3D11_BIND_RENDER_TARGET = 0x00000020L,
    D3D11_BIND_DEPTH_STENCIL = 0x00000040L,
    D3D11_BIND_UNORDERED_ACCESS = 0x00000080L,
    D3D11_BIND_DECODER = 0x00000200L,
    D3D11_BIND_VIDEO_ENCODER = 0x00000400L,
} D3D11_BIND_FLAG;

typedef enum D3D11_CPU_ACCESS_FLAG
{
    D3D11_CPU_ACCESS_WRITE = 0x00010000L,
    D3D11_CPU_ACCESS_READ = 0x00020000L,
} D3D11_CPU_ACCESS_FLAG;

typedef enum D3D11_RESOURCE_MISC_FLAG
{
    D3D11_RESOURCE_MISC_GENERATE_MIPS                   = 0x00000001L,
    D3D11_RESOURCE_MISC_SHARED                          = 0x00000002L,
    D3D11_RESOURCE_MISC_TEXTURECUBE                     = 0x00000004L,
    D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS               = 0x00000010L,
    D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS          = 0x00000020L,
    D3D11_RESOURCE_MISC_BUFFER_STRUCTURED               = 0x00000040L,
    D3D11_RESOURCE_MISC_RESOURCE_CLAMP                  = 0x00000080L,
    D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX               = 0x00000100L,
    D3D11_RESOURCE_MISC_GDI_COMPATIBLE                  = 0x00000200L,
    D3D11_RESOURCE_MISC_SHARED_NTHANDLE                 = 0x00000800L,
    D3D11_RESOURCE_MISC_RESTRICTED_CONTENT              = 0x00001000L,
    D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE        = 0x00002000L,
    D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER = 0x00004000L,
    D3D11_RESOURCE_MISC_GUARDED                         = 0x00008000L,
    D3D11_RESOURCE_MISC_TILE_POOL                       = 0x00020000L,
    D3D11_RESOURCE_MISC_TILED                           = 0x00040000L,
    D3D11_RESOURCE_MISC_HW_PROTECTED                    = 0x00080000L,
} D3D11_RESOURCE_MISC_FLAG;

typedef enum D3D11_MAP // for calling ID3D11Resource::Map()
{
    D3D11_MAP_READ = 1,
    D3D11_MAP_WRITE = 2,
    D3D11_MAP_READ_WRITE = 3,
    D3D11_MAP_WRITE_DISCARD = 4,
    D3D11_MAP_WRITE_NO_OVERWRITE = 5,
} D3D11_MAP;

typedef enum D3D11_MAP_FLAG
{
    D3D11_MAP_FLAG_DO_NOT_WAIT = 0x00100000L,
} D3D11_MAP_FLAG;

typedef enum D3D11_RAISE_FLAG
{
    D3D11_RAISE_FLAG_DRIVER_INTERNAL_ERROR = 0x1L,
} D3D11_RAISE_FLAG;

// Flags for ClearDepthStencil
typedef enum D3D11_CLEAR_FLAG
{
    D3D11_CLEAR_DEPTH = 0x01L,
    D3D11_CLEAR_STENCIL = 0x02L,
} D3D11_CLEAR_FLAG;

typedef RECT D3D11_RECT;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_RECT : public D3D11_RECT" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_RECT()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_RECT( const D3D11_RECT& o ) :" )
cpp_quote( "        D3D11_RECT( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_RECT(" )
cpp_quote( "        LONG Left," )
cpp_quote( "        LONG Top," )
cpp_quote( "        LONG Right," )
cpp_quote( "        LONG Bottom )" )
cpp_quote( "    {" )
cpp_quote( "        left = Left;" )
cpp_quote( "        top = Top;" )
cpp_quote( "        right = Right;" )
cpp_quote( "        bottom = Bottom;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_RECT() {}" )
cpp_quote( "    operator const D3D11_RECT&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "inline bool operator==( const D3D11_RECT& l, const D3D11_RECT& r )" )
cpp_quote( "{" )
cpp_quote( "    return l.left == r.left && l.top == r.top &&" )
cpp_quote( "        l.right == r.right && l.bottom == r.bottom;" )
cpp_quote( "}" )
cpp_quote( "inline bool operator!=( const D3D11_RECT& l, const D3D11_RECT& r )" )
cpp_quote( "{ return !( l == r ); }" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

typedef struct D3D11_BOX
{
    UINT left;
    UINT top;
    UINT front;
    UINT right;
    UINT bottom;
    UINT back;
} D3D11_BOX;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_BOX : public D3D11_BOX" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_BOX()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_BOX( const D3D11_BOX& o ) :" )
cpp_quote( "        D3D11_BOX( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_BOX(" )
cpp_quote( "        LONG Left," )
cpp_quote( "        LONG Top," )
cpp_quote( "        LONG Front," )
cpp_quote( "        LONG Right," )
cpp_quote( "        LONG Bottom," )
cpp_quote( "        LONG Back )" )
cpp_quote( "    {" )
cpp_quote( "        left = Left;" )
cpp_quote( "        top = Top;" )
cpp_quote( "        front = Front;" )
cpp_quote( "        right = Right;" )
cpp_quote( "        bottom = Bottom;" )
cpp_quote( "        back = Back;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_BOX() {}" )
cpp_quote( "    operator const D3D11_BOX&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "inline bool operator==( const D3D11_BOX& l, const D3D11_BOX& r )" )
cpp_quote( "{" )
cpp_quote( "    return l.left == r.left && l.top == r.top && l.front == r.front &&" )
cpp_quote( "        l.right == r.right && l.bottom == r.bottom && l.back == r.back;" )
cpp_quote( "}" )
cpp_quote( "inline bool operator!=( const D3D11_BOX& l, const D3D11_BOX& r )" )
cpp_quote( "{ return !( l == r ); }" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

// Forward declarations:
interface ID3D11Device;
interface ID3D11ClassLinkage;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// DeviceChild
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[ uuid( 1841e5c8-16b0-489b-bcc8-44cfb0d5deae ), object, local, pointer_default( unique ) ]
interface ID3D11DeviceChild
    : IUnknown
{
    void GetDevice( [annotation("_Outptr_")] ID3D11Device** ppDevice );
    HRESULT GetPrivateData(
        [annotation("_In_")] REFGUID guid,
        [annotation("_Inout_")] UINT* pDataSize,
        [annotation("_Out_writes_bytes_opt_( *pDataSize )")] void* pData );
    HRESULT SetPrivateData(
        [annotation("_In_")] REFGUID guid,
        [annotation("_In_")] UINT DataSize,
        [annotation("_In_reads_bytes_opt_( DataSize )")] const void* pData );
    HRESULT SetPrivateDataInterface(
        [annotation("_In_")] REFGUID guid,
        [annotation("_In_opt_")] const IUnknown * pData );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Depth-Stencil State
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Keep COMPARISON_FUNC values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D11_COMPARISON_FUNC
{
    D3D11_COMPARISON_NEVER = 1,
    D3D11_COMPARISON_LESS = 2,
    D3D11_COMPARISON_EQUAL = 3,
    D3D11_COMPARISON_LESS_EQUAL = 4,
    D3D11_COMPARISON_GREATER = 5,
    D3D11_COMPARISON_NOT_EQUAL = 6,
    D3D11_COMPARISON_GREATER_EQUAL = 7,
    D3D11_COMPARISON_ALWAYS = 8
} D3D11_COMPARISON_FUNC;

typedef enum D3D11_DEPTH_WRITE_MASK
{
    D3D11_DEPTH_WRITE_MASK_ZERO = 0,
    D3D11_DEPTH_WRITE_MASK_ALL = 1
} D3D11_DEPTH_WRITE_MASK;

// Keep STENCILOP values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D11_STENCIL_OP
{
    D3D11_STENCIL_OP_KEEP = 1,
    D3D11_STENCIL_OP_ZERO = 2,
    D3D11_STENCIL_OP_REPLACE = 3,
    D3D11_STENCIL_OP_INCR_SAT = 4,
    D3D11_STENCIL_OP_DECR_SAT = 5,
    D3D11_STENCIL_OP_INVERT = 6,
    D3D11_STENCIL_OP_INCR = 7,
    D3D11_STENCIL_OP_DECR = 8
} D3D11_STENCIL_OP;

typedef struct D3D11_DEPTH_STENCILOP_DESC
{
    D3D11_STENCIL_OP StencilFailOp;
    D3D11_STENCIL_OP StencilDepthFailOp;
    D3D11_STENCIL_OP StencilPassOp;
    D3D11_COMPARISON_FUNC StencilFunc;
} D3D11_DEPTH_STENCILOP_DESC;

typedef struct D3D11_DEPTH_STENCIL_DESC
{
    BOOL DepthEnable;
    D3D11_DEPTH_WRITE_MASK DepthWriteMask;
    D3D11_COMPARISON_FUNC DepthFunc;
    BOOL StencilEnable;
    UINT8 StencilReadMask;
    UINT8 StencilWriteMask;
    D3D11_DEPTH_STENCILOP_DESC FrontFace;
    D3D11_DEPTH_STENCILOP_DESC BackFace;
} D3D11_DEPTH_STENCIL_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_DEPTH_STENCIL_DESC : public D3D11_DEPTH_STENCIL_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_DEPTH_STENCIL_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_DESC( const D3D11_DEPTH_STENCIL_DESC& o ) :" )
cpp_quote( "        D3D11_DEPTH_STENCIL_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_DESC( CD3D11_DEFAULT )" )
cpp_quote( "    {" )
cpp_quote( "        DepthEnable = TRUE;" )
cpp_quote( "        DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;" )
cpp_quote( "        DepthFunc = D3D11_COMPARISON_LESS;" )
cpp_quote( "        StencilEnable = FALSE;" )
cpp_quote( "        StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;" )
cpp_quote( "        StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;" )
cpp_quote( "        const D3D11_DEPTH_STENCILOP_DESC defaultStencilOp =" )
cpp_quote( "        { D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_KEEP, D3D11_COMPARISON_ALWAYS };" )
cpp_quote( "        FrontFace = defaultStencilOp;" )
cpp_quote( "        BackFace = defaultStencilOp;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_DESC(" )
cpp_quote( "        BOOL depthEnable," )
cpp_quote( "        D3D11_DEPTH_WRITE_MASK depthWriteMask," )
cpp_quote( "        D3D11_COMPARISON_FUNC depthFunc," )
cpp_quote( "        BOOL stencilEnable," )
cpp_quote( "        UINT8 stencilReadMask," )
cpp_quote( "        UINT8 stencilWriteMask," )
cpp_quote( "        D3D11_STENCIL_OP frontStencilFailOp," )
cpp_quote( "        D3D11_STENCIL_OP frontStencilDepthFailOp," )
cpp_quote( "        D3D11_STENCIL_OP frontStencilPassOp," )
cpp_quote( "        D3D11_COMPARISON_FUNC frontStencilFunc," )
cpp_quote( "        D3D11_STENCIL_OP backStencilFailOp," )
cpp_quote( "        D3D11_STENCIL_OP backStencilDepthFailOp," )
cpp_quote( "        D3D11_STENCIL_OP backStencilPassOp," )
cpp_quote( "        D3D11_COMPARISON_FUNC backStencilFunc )" )
cpp_quote( "    {" )
cpp_quote( "        DepthEnable = depthEnable;" )
cpp_quote( "        DepthWriteMask = depthWriteMask;" )
cpp_quote( "        DepthFunc = depthFunc;" )
cpp_quote( "        StencilEnable = stencilEnable;" )
cpp_quote( "        StencilReadMask = stencilReadMask;" )
cpp_quote( "        StencilWriteMask = stencilWriteMask;" )
cpp_quote( "        FrontFace.StencilFailOp = frontStencilFailOp;" )
cpp_quote( "        FrontFace.StencilDepthFailOp = frontStencilDepthFailOp;" )
cpp_quote( "        FrontFace.StencilPassOp = frontStencilPassOp;" )
cpp_quote( "        FrontFace.StencilFunc = frontStencilFunc;" )
cpp_quote( "        BackFace.StencilFailOp = backStencilFailOp;" )
cpp_quote( "        BackFace.StencilDepthFailOp = backStencilDepthFailOp;" )
cpp_quote( "        BackFace.StencilPassOp = backStencilPassOp;" )
cpp_quote( "        BackFace.StencilFunc = backStencilFunc;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_DEPTH_STENCIL_DESC() {}" )
cpp_quote( "    operator const D3D11_DEPTH_STENCIL_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 03823efb-8d8f-4e1c-9aa2-f64bb2cbfdf1 ), object, local, pointer_default( unique ) ]
interface ID3D11DepthStencilState
    : ID3D11DeviceChild
{
    void GetDesc( [annotation("_Out_")] D3D11_DEPTH_STENCIL_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Blend State
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Keep BLEND values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D11_BLEND
{
    D3D11_BLEND_ZERO = 1,
    D3D11_BLEND_ONE = 2,
    D3D11_BLEND_SRC_COLOR = 3, // PS output oN.rgb (N is current RT being blended)
    D3D11_BLEND_INV_SRC_COLOR = 4, // 1.0f - PS output oN.rgb
    D3D11_BLEND_SRC_ALPHA = 5, // PS output oN.a
    D3D11_BLEND_INV_SRC_ALPHA = 6, // 1.0f - PS output oN.a
    D3D11_BLEND_DEST_ALPHA = 7, // RT(N).a (N is current RT being blended)
    D3D11_BLEND_INV_DEST_ALPHA = 8, // 1.0f - RT(N).a
    D3D11_BLEND_DEST_COLOR = 9, // RT(N).rgb
    D3D11_BLEND_INV_DEST_COLOR = 10,// 1.0f - RT(N).rgb
    D3D11_BLEND_SRC_ALPHA_SAT = 11,// (f,f,f,1), f = min(1 - RT(N).a, oN.a)
    // 12 reserved (was BOTHSRCALPHA)
    // 13 reserved (was BOTHSRCALPHA)
    D3D11_BLEND_BLEND_FACTOR = 14,
    D3D11_BLEND_INV_BLEND_FACTOR = 15,
    D3D11_BLEND_SRC1_COLOR = 16, // PS output o1.rgb
    D3D11_BLEND_INV_SRC1_COLOR = 17, // 1.0f - PS output o1.rgb
    D3D11_BLEND_SRC1_ALPHA = 18, // PS output o1.a
    D3D11_BLEND_INV_SRC1_ALPHA = 19, // 1.0f - PS output o1.a
} D3D11_BLEND;

// Keep BLENDOP values in sync with earlier DX versions (HW consumes values directly).
typedef enum D3D11_BLEND_OP
{
    D3D11_BLEND_OP_ADD = 1,
    D3D11_BLEND_OP_SUBTRACT = 2,
    D3D11_BLEND_OP_REV_SUBTRACT = 3,
    D3D11_BLEND_OP_MIN = 4, // min semantics are like min shader instruction
    D3D11_BLEND_OP_MAX = 5, // max semantics are like max shader instruction
} D3D11_BLEND_OP;

typedef enum D3D11_COLOR_WRITE_ENABLE
{
    D3D11_COLOR_WRITE_ENABLE_RED = 1,
    D3D11_COLOR_WRITE_ENABLE_GREEN = 2,
    D3D11_COLOR_WRITE_ENABLE_BLUE = 4,
    D3D11_COLOR_WRITE_ENABLE_ALPHA = 8,
    D3D11_COLOR_WRITE_ENABLE_ALL = (D3D11_COLOR_WRITE_ENABLE_RED|D3D11_COLOR_WRITE_ENABLE_GREEN|
        D3D11_COLOR_WRITE_ENABLE_BLUE|D3D11_COLOR_WRITE_ENABLE_ALPHA),
} D3D11_COLOR_WRITE_ENABLE;

typedef struct D3D11_RENDER_TARGET_BLEND_DESC
{
    BOOL BlendEnable;
    D3D11_BLEND SrcBlend;
    D3D11_BLEND DestBlend;
    D3D11_BLEND_OP BlendOp;
    D3D11_BLEND SrcBlendAlpha;
    D3D11_BLEND DestBlendAlpha;
    D3D11_BLEND_OP BlendOpAlpha;
    UINT8 RenderTargetWriteMask; // D3D11_COLOR_WRITE_ENABLE
} D3D11_RENDER_TARGET_BLEND_DESC;

typedef struct D3D11_BLEND_DESC
{
    BOOL AlphaToCoverageEnable; // relevant to multisample antialiasing only
    BOOL IndependentBlendEnable; // if FALSE, then replicate the first entry in RenderTarget array to other entries
    D3D11_RENDER_TARGET_BLEND_DESC RenderTarget[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
} D3D11_BLEND_DESC;
cpp_quote( "/* Note, the array size for RenderTarget[] above is D3D11_SIMULTANEOUS_RENDERTARGET_COUNT. ")
cpp_quote( "   IDL processing/generation of this header replaces the define; this comment is merely explaining what happened. */" ) 

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_BLEND_DESC : public D3D11_BLEND_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_BLEND_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_BLEND_DESC( const D3D11_BLEND_DESC& o ) :" )
cpp_quote( "        D3D11_BLEND_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_BLEND_DESC( CD3D11_DEFAULT )" )
cpp_quote( "    {" )
cpp_quote( "        AlphaToCoverageEnable = FALSE;" )
cpp_quote( "        IndependentBlendEnable = FALSE;" )
cpp_quote( "        const D3D11_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc =" )
cpp_quote( "        {" )
cpp_quote( "            FALSE," )
cpp_quote( "            D3D11_BLEND_ONE, D3D11_BLEND_ZERO, D3D11_BLEND_OP_ADD," )
cpp_quote( "            D3D11_BLEND_ONE, D3D11_BLEND_ZERO, D3D11_BLEND_OP_ADD," )
cpp_quote( "            D3D11_COLOR_WRITE_ENABLE_ALL," )
cpp_quote( "        };" )
cpp_quote( "        for (UINT i = 0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i)" )
cpp_quote( "            RenderTarget[ i ] = defaultRenderTargetBlendDesc;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_BLEND_DESC() {}" )
cpp_quote( "    operator const D3D11_BLEND_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 75b68faa-347d-4159-8f45-a0640f01cd9a ), object, local, pointer_default( unique ) ]
interface ID3D11BlendState
    : ID3D11DeviceChild
{
    void GetDesc( [annotation("_Out_")] D3D11_BLEND_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Rasterizer State
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef struct D3D11_RASTERIZER_DESC
{
    D3D11_FILL_MODE FillMode;
    D3D11_CULL_MODE CullMode;
    BOOL FrontCounterClockwise;
    INT DepthBias;
    FLOAT DepthBiasClamp;
    FLOAT SlopeScaledDepthBias;
    BOOL DepthClipEnable;
    BOOL ScissorEnable;
    BOOL MultisampleEnable;
    BOOL AntialiasedLineEnable;
} D3D11_RASTERIZER_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_RASTERIZER_DESC : public D3D11_RASTERIZER_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_RASTERIZER_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_RASTERIZER_DESC( const D3D11_RASTERIZER_DESC& o ) :" )
cpp_quote( "        D3D11_RASTERIZER_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_RASTERIZER_DESC( CD3D11_DEFAULT )" )
cpp_quote( "    {" )
cpp_quote( "        FillMode = D3D11_FILL_SOLID;" )
cpp_quote( "        CullMode = D3D11_CULL_BACK;" )
cpp_quote( "        FrontCounterClockwise = FALSE;" )
cpp_quote( "        DepthBias = D3D11_DEFAULT_DEPTH_BIAS;" )
cpp_quote( "        DepthBiasClamp = D3D11_DEFAULT_DEPTH_BIAS_CLAMP;" )
cpp_quote( "        SlopeScaledDepthBias = D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;" )
cpp_quote( "        DepthClipEnable = TRUE;" )
cpp_quote( "        ScissorEnable = FALSE;" )
cpp_quote( "        MultisampleEnable = FALSE;" )
cpp_quote( "        AntialiasedLineEnable = FALSE;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_RASTERIZER_DESC(" )
cpp_quote( "        D3D11_FILL_MODE fillMode," )
cpp_quote( "        D3D11_CULL_MODE cullMode," )
cpp_quote( "        BOOL frontCounterClockwise," )
cpp_quote( "        INT depthBias," )
cpp_quote( "        FLOAT depthBiasClamp," )
cpp_quote( "        FLOAT slopeScaledDepthBias," )
cpp_quote( "        BOOL depthClipEnable," )
cpp_quote( "        BOOL scissorEnable," )
cpp_quote( "        BOOL multisampleEnable," )
cpp_quote( "        BOOL antialiasedLineEnable )" )
cpp_quote( "    {" )
cpp_quote( "        FillMode = fillMode;" )
cpp_quote( "        CullMode = cullMode;" )
cpp_quote( "        FrontCounterClockwise = frontCounterClockwise;" )
cpp_quote( "        DepthBias = depthBias;" )
cpp_quote( "        DepthBiasClamp = depthBiasClamp;" )
cpp_quote( "        SlopeScaledDepthBias = slopeScaledDepthBias;" )
cpp_quote( "        DepthClipEnable = depthClipEnable;" )
cpp_quote( "        ScissorEnable = scissorEnable;" )
cpp_quote( "        MultisampleEnable = multisampleEnable;" )
cpp_quote( "        AntialiasedLineEnable = antialiasedLineEnable;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_RASTERIZER_DESC() {}" )
cpp_quote( "    operator const D3D11_RASTERIZER_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 9bb4ab81-ab1a-4d8f-b506-fc04200b6ee7 ), object, local, pointer_default( unique ) ]
interface ID3D11RasterizerState
    : ID3D11DeviceChild
{
    void GetDesc( [annotation("_Out_")] D3D11_RASTERIZER_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Resource
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "inline UINT D3D11CalcSubresource( UINT MipSlice, UINT ArraySlice, UINT MipLevels )" )
cpp_quote( "{ return MipSlice + ArraySlice * MipLevels; }" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

typedef struct D3D11_SUBRESOURCE_DATA
{
    const void *pSysMem;
    UINT SysMemPitch;
    UINT SysMemSlicePitch;
} D3D11_SUBRESOURCE_DATA;

typedef struct D3D11_MAPPED_SUBRESOURCE
{
    void *pData;
    UINT RowPitch;
    UINT DepthPitch;
} D3D11_MAPPED_SUBRESOURCE;

[ uuid( dc8e63f3-d12b-4952-b47b-5e45026a862d ), object, local, pointer_default( unique ) ]
interface ID3D11Resource
    : ID3D11DeviceChild
{
    void GetType( [annotation("_Out_")] D3D11_RESOURCE_DIMENSION* pResourceDimension );
    void SetEvictionPriority( [annotation("_In_")] UINT EvictionPriority );
    UINT GetEvictionPriority();
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Buffer
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_BUFFER_DESC
{
    UINT ByteWidth;
    D3D11_USAGE Usage;
    UINT BindFlags;
    UINT CPUAccessFlags;    
    UINT MiscFlags;
    UINT StructureByteStride; // Stride of Structured Buffer; ignored if STRUCTURED MiscFlag not set
} D3D11_BUFFER_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_BUFFER_DESC : public D3D11_BUFFER_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_BUFFER_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_BUFFER_DESC( const D3D11_BUFFER_DESC& o ) :" )
cpp_quote( "        D3D11_BUFFER_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_BUFFER_DESC(" )
cpp_quote( "        UINT byteWidth," )
cpp_quote( "        UINT bindFlags," )
cpp_quote( "        D3D11_USAGE usage = D3D11_USAGE_DEFAULT," )
cpp_quote( "        UINT cpuaccessFlags = 0," )
cpp_quote( "        UINT miscFlags = 0," )
cpp_quote( "        UINT structureByteStride = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        ByteWidth = byteWidth;" )
cpp_quote( "        Usage = usage;" )
cpp_quote( "        BindFlags = bindFlags;" )
cpp_quote( "        CPUAccessFlags = cpuaccessFlags ;" )
cpp_quote( "        MiscFlags = miscFlags;" )
cpp_quote( "        StructureByteStride = structureByteStride;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_BUFFER_DESC() {}" )
cpp_quote( "    operator const D3D11_BUFFER_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 48570b85-d1ee-4fcd-a250-eb350722b037 ), object, local, pointer_default( unique ) ]
interface ID3D11Buffer
    : ID3D11Resource
{
    void GetDesc( [annotation("_Out_")] D3D11_BUFFER_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Texture1D
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_TEXTURE1D_DESC
{
    UINT Width;
    UINT MipLevels;
    UINT ArraySize;
    DXGI_FORMAT Format;
    D3D11_USAGE Usage;
    UINT BindFlags;
    UINT CPUAccessFlags;    
    UINT MiscFlags;
} D3D11_TEXTURE1D_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_TEXTURE1D_DESC : public D3D11_TEXTURE1D_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_TEXTURE1D_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_TEXTURE1D_DESC( const D3D11_TEXTURE1D_DESC& o ) :" )
cpp_quote( "        D3D11_TEXTURE1D_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_TEXTURE1D_DESC(" )
cpp_quote( "        DXGI_FORMAT format," )
cpp_quote( "        UINT width," )
cpp_quote( "        UINT arraySize = 1," )
cpp_quote( "        UINT mipLevels = 0," )
cpp_quote( "        UINT bindFlags = D3D11_BIND_SHADER_RESOURCE," )
cpp_quote( "        D3D11_USAGE usage = D3D11_USAGE_DEFAULT," )
cpp_quote( "        UINT cpuaccessFlags= 0," )
cpp_quote( "        UINT miscFlags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Width = width;" )
cpp_quote( "        MipLevels = mipLevels;" )
cpp_quote( "        ArraySize = arraySize;" )
cpp_quote( "        Format = format;" )
cpp_quote( "        Usage = usage;" )
cpp_quote( "        BindFlags = bindFlags;" )
cpp_quote( "        CPUAccessFlags = cpuaccessFlags;" )
cpp_quote( "        MiscFlags = miscFlags;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_TEXTURE1D_DESC() {}" )
cpp_quote( "    operator const D3D11_TEXTURE1D_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( f8fb5c27-c6b3-4f75-a4c8-439af2ef564c ), object, local, pointer_default( unique ) ]
interface ID3D11Texture1D
    : ID3D11Resource
{
    void GetDesc( [annotation("_Out_")] D3D11_TEXTURE1D_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Texture2D
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_TEXTURE2D_DESC
{
    UINT Width;
    UINT Height;
    UINT MipLevels;
    UINT ArraySize;
    DXGI_FORMAT Format;
    DXGI_SAMPLE_DESC SampleDesc;
    D3D11_USAGE Usage;
    UINT BindFlags;
    UINT CPUAccessFlags;    
    UINT MiscFlags;
} D3D11_TEXTURE2D_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_TEXTURE2D_DESC : public D3D11_TEXTURE2D_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_TEXTURE2D_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_TEXTURE2D_DESC( const D3D11_TEXTURE2D_DESC& o ) :" )
cpp_quote( "        D3D11_TEXTURE2D_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_TEXTURE2D_DESC(" )
cpp_quote( "        DXGI_FORMAT format," )
cpp_quote( "        UINT width," )
cpp_quote( "        UINT height," )
cpp_quote( "        UINT arraySize = 1," )
cpp_quote( "        UINT mipLevels = 0," )
cpp_quote( "        UINT bindFlags = D3D11_BIND_SHADER_RESOURCE," )
cpp_quote( "        D3D11_USAGE usage = D3D11_USAGE_DEFAULT," )
cpp_quote( "        UINT cpuaccessFlags = 0," )
cpp_quote( "        UINT sampleCount = 1," )
cpp_quote( "        UINT sampleQuality = 0," )
cpp_quote( "        UINT miscFlags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Width = width;" )
cpp_quote( "        Height = height;" )
cpp_quote( "        MipLevels = mipLevels;" )
cpp_quote( "        ArraySize = arraySize;" )
cpp_quote( "        Format = format;" )
cpp_quote( "        SampleDesc.Count = sampleCount;" )
cpp_quote( "        SampleDesc.Quality = sampleQuality;" )
cpp_quote( "        Usage = usage;" )
cpp_quote( "        BindFlags = bindFlags;" )
cpp_quote( "        CPUAccessFlags = cpuaccessFlags;" )
cpp_quote( "        MiscFlags = miscFlags;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_TEXTURE2D_DESC() {}" )
cpp_quote( "    operator const D3D11_TEXTURE2D_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 6f15aaf2-d208-4e89-9ab4-489535d34f9c ), object, local, pointer_default( unique ) ]
interface ID3D11Texture2D
    : ID3D11Resource
{
    void GetDesc( [annotation("_Out_")] D3D11_TEXTURE2D_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Texture3D
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_TEXTURE3D_DESC
{
    UINT Width;
    UINT Height;
    UINT Depth;
    UINT MipLevels;
    DXGI_FORMAT Format;
    D3D11_USAGE Usage;    
    UINT BindFlags;
    UINT CPUAccessFlags;    
    UINT MiscFlags;
} D3D11_TEXTURE3D_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_TEXTURE3D_DESC : public D3D11_TEXTURE3D_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_TEXTURE3D_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_TEXTURE3D_DESC( const D3D11_TEXTURE3D_DESC& o ) :" )
cpp_quote( "        D3D11_TEXTURE3D_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_TEXTURE3D_DESC(" )
cpp_quote( "        DXGI_FORMAT format," )
cpp_quote( "        UINT width," )
cpp_quote( "        UINT height," )
cpp_quote( "        UINT depth," )
cpp_quote( "        UINT mipLevels = 0," )
cpp_quote( "        UINT bindFlags = D3D11_BIND_SHADER_RESOURCE," )
cpp_quote( "        D3D11_USAGE usage = D3D11_USAGE_DEFAULT," )
cpp_quote( "        UINT cpuaccessFlags = 0," )
cpp_quote( "        UINT miscFlags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Width = width;" )
cpp_quote( "        Height = height;" )
cpp_quote( "        Depth = depth;" )
cpp_quote( "        MipLevels = mipLevels;" )
cpp_quote( "        Format = format;" )
cpp_quote( "        Usage = usage;" )
cpp_quote( "        BindFlags = bindFlags;" )
cpp_quote( "        CPUAccessFlags = cpuaccessFlags;" )
cpp_quote( "        MiscFlags = miscFlags;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_TEXTURE3D_DESC() {}" )
cpp_quote( "    operator const D3D11_TEXTURE3D_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 037e866e-f56d-4357-a8af-9dabbe6e250e ), object, local, pointer_default( unique ) ]
interface ID3D11Texture3D
    : ID3D11Resource
{
    void GetDesc( [annotation("_Out_")] D3D11_TEXTURE3D_DESC* pDesc );
};

/* TextureCube Face identifiers */
typedef enum D3D11_TEXTURECUBE_FACE
{
    D3D11_TEXTURECUBE_FACE_POSITIVE_X = 0,
    D3D11_TEXTURECUBE_FACE_NEGATIVE_X = 1,
    D3D11_TEXTURECUBE_FACE_POSITIVE_Y = 2,
    D3D11_TEXTURECUBE_FACE_NEGATIVE_Y = 3,
    D3D11_TEXTURECUBE_FACE_POSITIVE_Z = 4,
    D3D11_TEXTURECUBE_FACE_NEGATIVE_Z = 5
} D3D11_TEXTURECUBE_FACE;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// View
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( 839d1216-bb2e-412b-b7f4-a9dbebe08ed1 ), object, local, pointer_default( unique ) ]
interface ID3D11View
    : ID3D11DeviceChild
{
    void GetResource( [annotation("_Outptr_")] ID3D11Resource** ppResource );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ShaderResourceView
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_BUFFER_SRV
{
    union
    {
        UINT FirstElement;  // Nicer name
        UINT ElementOffset;
    };
    union
    {
        UINT NumElements;   // Nicer name
        UINT ElementWidth;  
    };
} D3D11_BUFFER_SRV;

typedef enum D3D11_BUFFEREX_SRV_FLAG
{
    D3D11_BUFFEREX_SRV_FLAG_RAW = 0x00000001,      // allow device multi-component reads with DWORD addressing
} D3D11_BUFFEREX_SRV_FLAG;

typedef struct D3D11_BUFFEREX_SRV
{
    UINT FirstElement;
    UINT NumElements;
    UINT Flags;
} D3D11_BUFFEREX_SRV;

typedef struct D3D11_TEX1D_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
 } D3D11_TEX1D_SRV;

typedef struct D3D11_TEX1D_ARRAY_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX1D_ARRAY_SRV;

typedef struct D3D11_TEX2D_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
} D3D11_TEX2D_SRV;

typedef struct D3D11_TEX2D_ARRAY_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2D_ARRAY_SRV;

typedef struct D3D11_TEX3D_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
} D3D11_TEX3D_SRV;

typedef struct D3D11_TEXCUBE_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
} D3D11_TEXCUBE_SRV;

typedef struct D3D11_TEXCUBE_ARRAY_SRV
{
    UINT MostDetailedMip;
    UINT MipLevels;
    UINT First2DArrayFace;  
    UINT NumCubes;
} D3D11_TEXCUBE_ARRAY_SRV;

typedef struct D3D11_TEX2DMS_SRV
{
    // don't need to define anything specific for this view dimension
    UINT UnusedField_NothingToDefine;
} D3D11_TEX2DMS_SRV;

typedef struct D3D11_TEX2DMS_ARRAY_SRV
{
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2DMS_ARRAY_SRV;

typedef struct D3D11_SHADER_RESOURCE_VIEW_DESC
{
    DXGI_FORMAT Format;
    D3D11_SRV_DIMENSION ViewDimension;

    union
    {
        D3D11_BUFFER_SRV Buffer;
        D3D11_TEX1D_SRV Texture1D;
        D3D11_TEX1D_ARRAY_SRV Texture1DArray;
        D3D11_TEX2D_SRV Texture2D;
        D3D11_TEX2D_ARRAY_SRV Texture2DArray;
        D3D11_TEX2DMS_SRV Texture2DMS;
        D3D11_TEX2DMS_ARRAY_SRV Texture2DMSArray;
        D3D11_TEX3D_SRV Texture3D;
        D3D11_TEXCUBE_SRV TextureCube;
        D3D11_TEXCUBE_ARRAY_SRV TextureCubeArray;
        D3D11_BUFFEREX_SRV BufferEx;
    };
} D3D11_SHADER_RESOURCE_VIEW_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_SHADER_RESOURCE_VIEW_DESC : public D3D11_SHADER_RESOURCE_VIEW_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_SHADER_RESOURCE_VIEW_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_SHADER_RESOURCE_VIEW_DESC( const D3D11_SHADER_RESOURCE_VIEW_DESC& o ) :" )
cpp_quote( "        D3D11_SHADER_RESOURCE_VIEW_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(" )
cpp_quote( "        D3D11_SRV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mostDetailedMip = 0, // FirstElement for BUFFER" )
cpp_quote( "        UINT mipLevels = -1, // NumElements for BUFFER" )
cpp_quote( "        UINT firstArraySlice = 0, // First2DArrayFace for TEXTURECUBEARRAY" )
cpp_quote( "        UINT arraySize = -1, // NumCubes for TEXTURECUBEARRAY" )
cpp_quote( "        UINT flags = 0 ) // BUFFEREX only" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_SRV_DIMENSION_BUFFER:" )
cpp_quote( "            Buffer.FirstElement = mostDetailedMip;" )
cpp_quote( "            Buffer.NumElements = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture1D.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture1DArray.MipLevels = mipLevels;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture2D.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture2DArray.MipLevels = mipLevels;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            Texture2DMSArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DMSArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE3D:" )
cpp_quote( "            Texture3D.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture3D.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURECUBE:" )
cpp_quote( "            TextureCube.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            TextureCube.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:" )
cpp_quote( "            TextureCubeArray.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            TextureCubeArray.MipLevels = mipLevels;" )
cpp_quote( "            TextureCubeArray.First2DArrayFace = firstArraySlice;" )
cpp_quote( "            TextureCubeArray.NumCubes = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_BUFFEREX:" )
cpp_quote( "            BufferEx.FirstElement = mostDetailedMip;" )
cpp_quote( "            BufferEx.NumElements = mipLevels;" )
cpp_quote( "            BufferEx.Flags = flags;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Buffer*," )
cpp_quote( "        DXGI_FORMAT format," )
cpp_quote( "        UINT firstElement," )
cpp_quote( "        UINT numElements," )
cpp_quote( "        UINT flags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;" )
cpp_quote( "        BufferEx.FirstElement = firstElement;" )
cpp_quote( "        BufferEx.NumElements = numElements;" )
cpp_quote( "        BufferEx.Flags = flags;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture1D* pTex1D," )
cpp_quote( "        D3D11_SRV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mostDetailedMip = 0," )
cpp_quote( "        UINT mipLevels = -1," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || -1 == mipLevels ||" )
cpp_quote( "            (-1 == arraySize && D3D11_SRV_DIMENSION_TEXTURE1DARRAY == viewDimension))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE1D_DESC TexDesc;" )
cpp_quote( "            pTex1D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == mipLevels) mipLevels = TexDesc.MipLevels - mostDetailedMip;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture1D.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture1DArray.MipLevels = mipLevels;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture2D* pTex2D," )
cpp_quote( "        D3D11_SRV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mostDetailedMip = 0," )
cpp_quote( "        UINT mipLevels = -1," )
cpp_quote( "        UINT firstArraySlice = 0, // First2DArrayFace for TEXTURECUBEARRAY" )
cpp_quote( "        UINT arraySize = -1 ) // NumCubes for TEXTURECUBEARRAY" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || " )
cpp_quote( "            (-1 == mipLevels &&" )
cpp_quote( "                D3D11_SRV_DIMENSION_TEXTURE2DMS != viewDimension &&" )
cpp_quote( "                D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY != viewDimension) ||" )
cpp_quote( "            (-1 == arraySize &&" )
cpp_quote( "                (D3D11_SRV_DIMENSION_TEXTURE2DARRAY == viewDimension ||" )
cpp_quote( "                D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY == viewDimension ||" )
cpp_quote( "                D3D11_SRV_DIMENSION_TEXTURECUBEARRAY == viewDimension)))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE2D_DESC TexDesc;" )
cpp_quote( "            pTex2D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == mipLevels) mipLevels = TexDesc.MipLevels - mostDetailedMip;" )
cpp_quote( "            if (-1 == arraySize)" )
cpp_quote( "            {" )
cpp_quote( "                arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "                if (D3D11_SRV_DIMENSION_TEXTURECUBEARRAY == viewDimension) arraySize /= 6;" )
cpp_quote( "            }" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture2D.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            Texture2DArray.MipLevels = mipLevels;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            Texture2DMSArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DMSArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURECUBE:" )
cpp_quote( "            TextureCube.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            TextureCube.MipLevels = mipLevels;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:" )
cpp_quote( "            TextureCubeArray.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "            TextureCubeArray.MipLevels = mipLevels;" )
cpp_quote( "            TextureCubeArray.First2DArrayFace = firstArraySlice;" )
cpp_quote( "            TextureCubeArray.NumCubes = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_SHADER_RESOURCE_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture3D* pTex3D," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mostDetailedMip = 0," )
cpp_quote( "        UINT mipLevels = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || -1 == mipLevels)" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE3D_DESC TexDesc;" )
cpp_quote( "            pTex3D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == mipLevels) mipLevels = TexDesc.MipLevels - mostDetailedMip;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        Texture3D.MostDetailedMip = mostDetailedMip;" )
cpp_quote( "        Texture3D.MipLevels = mipLevels;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_SHADER_RESOURCE_VIEW_DESC() {}" )
cpp_quote( "    operator const D3D11_SHADER_RESOURCE_VIEW_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( b0e06fe0-8192-4e1a-b1ca-36d7414710b2 ), object, local, pointer_default( unique ) ]
interface ID3D11ShaderResourceView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// RenderTargetView
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_BUFFER_RTV
{
    union
    {
        UINT FirstElement;  // Nicer name
        UINT ElementOffset;
    };
    union
    {
        UINT NumElements;   // Nicer name
        UINT ElementWidth; 
    };
} D3D11_BUFFER_RTV;

typedef struct D3D11_TEX1D_RTV
{
    UINT MipSlice;
} D3D11_TEX1D_RTV;

typedef struct D3D11_TEX1D_ARRAY_RTV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX1D_ARRAY_RTV;

typedef struct D3D11_TEX2D_RTV
{
    UINT MipSlice;
} D3D11_TEX2D_RTV;

typedef struct D3D11_TEX2DMS_RTV
{
    UINT UnusedField_NothingToDefine;
} D3D11_TEX2DMS_RTV;

typedef struct D3D11_TEX2D_ARRAY_RTV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2D_ARRAY_RTV;

typedef struct D3D11_TEX2DMS_ARRAY_RTV
{
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2DMS_ARRAY_RTV;

typedef struct D3D11_TEX3D_RTV
{
    UINT MipSlice;
    UINT FirstWSlice;
    UINT WSize;
} D3D11_TEX3D_RTV;

typedef struct D3D11_RENDER_TARGET_VIEW_DESC
{
    DXGI_FORMAT Format;
    D3D11_RTV_DIMENSION ViewDimension;

    union
    {
        D3D11_BUFFER_RTV Buffer;
        D3D11_TEX1D_RTV Texture1D;
        D3D11_TEX1D_ARRAY_RTV Texture1DArray;
        D3D11_TEX2D_RTV Texture2D;
        D3D11_TEX2D_ARRAY_RTV Texture2DArray;
        D3D11_TEX2DMS_RTV Texture2DMS;
        D3D11_TEX2DMS_ARRAY_RTV Texture2DMSArray;
        D3D11_TEX3D_RTV Texture3D;
    };
} D3D11_RENDER_TARGET_VIEW_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_RENDER_TARGET_VIEW_DESC : public D3D11_RENDER_TARGET_VIEW_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_RENDER_TARGET_VIEW_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_RENDER_TARGET_VIEW_DESC( const D3D11_RENDER_TARGET_VIEW_DESC& o ) :" )
cpp_quote( "        D3D11_RENDER_TARGET_VIEW_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_RENDER_TARGET_VIEW_DESC(" )
cpp_quote( "        D3D11_RTV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0, // FirstElement for BUFFER" )
cpp_quote( "        UINT firstArraySlice = 0, // NumElements for BUFFER, FirstWSlice for TEXTURE3D" )
cpp_quote( "        UINT arraySize = -1 ) // WSize for TEXTURE3D" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_BUFFER:" )
cpp_quote( "            Buffer.FirstElement = mipSlice;" )
cpp_quote( "            Buffer.NumElements = firstArraySlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            Texture2DMSArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DMSArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE3D:" )
cpp_quote( "            Texture3D.MipSlice = mipSlice;" )
cpp_quote( "            Texture3D.FirstWSlice = firstArraySlice;" )
cpp_quote( "            Texture3D.WSize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_RENDER_TARGET_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Buffer*," )
cpp_quote( "        DXGI_FORMAT format," )
cpp_quote( "        UINT firstElement," )
cpp_quote( "        UINT numElements )" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = D3D11_RTV_DIMENSION_BUFFER;" )
cpp_quote( "        Buffer.FirstElement = firstElement;" )
cpp_quote( "        Buffer.NumElements = numElements;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_RENDER_TARGET_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture1D* pTex1D," )
cpp_quote( "        D3D11_RTV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format ||" )
cpp_quote( "            (-1 == arraySize && D3D11_RTV_DIMENSION_TEXTURE1DARRAY == viewDimension))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE1D_DESC TexDesc;" )
cpp_quote( "            pTex1D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_RENDER_TARGET_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture2D* pTex2D," )
cpp_quote( "        D3D11_RTV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || " )
cpp_quote( "            (-1 == arraySize &&" )
cpp_quote( "                (D3D11_RTV_DIMENSION_TEXTURE2DARRAY == viewDimension ||" )
cpp_quote( "                D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY == viewDimension)))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE2D_DESC TexDesc;" )
cpp_quote( "            pTex2D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            Texture2DMSArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DMSArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_RENDER_TARGET_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture3D* pTex3D," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstWSlice = 0," )
cpp_quote( "        UINT wSize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || -1 == wSize)" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE3D_DESC TexDesc;" )
cpp_quote( "            pTex3D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == wSize) wSize = TexDesc.Depth - firstWSlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        Texture3D.MipSlice = mipSlice;" )
cpp_quote( "        Texture3D.FirstWSlice = firstWSlice;" )
cpp_quote( "        Texture3D.WSize = wSize;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_RENDER_TARGET_VIEW_DESC() {}" )
cpp_quote( "    operator const D3D11_RENDER_TARGET_VIEW_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( dfdba067-0b8d-4865-875b-d7b4516cc164 ), object, local, pointer_default( unique ) ]
interface ID3D11RenderTargetView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_RENDER_TARGET_VIEW_DESC* pDesc );
};

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_VIEWPORT : public D3D11_VIEWPORT" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_VIEWPORT()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_VIEWPORT( const D3D11_VIEWPORT& o ) :" )
cpp_quote( "        D3D11_VIEWPORT( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_VIEWPORT(" )
cpp_quote( "        FLOAT topLeftX," )
cpp_quote( "        FLOAT topLeftY," )
cpp_quote( "        FLOAT width," )
cpp_quote( "        FLOAT height," )
cpp_quote( "        FLOAT minDepth = D3D11_MIN_DEPTH," )
cpp_quote( "        FLOAT maxDepth = D3D11_MAX_DEPTH )" )
cpp_quote( "    {" )
cpp_quote( "        TopLeftX = topLeftX;" )
cpp_quote( "        TopLeftY = topLeftY;" )
cpp_quote( "        Width = width;" )
cpp_quote( "        Height = height;" )
cpp_quote( "        MinDepth = minDepth;" )
cpp_quote( "        MaxDepth = maxDepth;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_VIEWPORT(" )
cpp_quote( "        _In_ ID3D11Buffer*," )
cpp_quote( "        _In_ ID3D11RenderTargetView* pRTView," )
cpp_quote( "        FLOAT topLeftX = 0.0f," )
cpp_quote( "        FLOAT minDepth = D3D11_MIN_DEPTH," )
cpp_quote( "        FLOAT maxDepth = D3D11_MAX_DEPTH )" )
cpp_quote( "    {" )
cpp_quote( "        D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;" )
cpp_quote( "        pRTView->GetDesc( &RTVDesc );" )
cpp_quote( "        UINT NumElements = 0;" )
cpp_quote( "        switch (RTVDesc.ViewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_BUFFER:" )
cpp_quote( "            NumElements = RTVDesc.Buffer.NumElements;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "        TopLeftX = topLeftX;" )
cpp_quote( "        TopLeftY = 0.0f;" )
cpp_quote( "        Width = NumElements - topLeftX;" )
cpp_quote( "        Height = 1.0f;" )
cpp_quote( "        MinDepth = minDepth;" )
cpp_quote( "        MaxDepth = maxDepth;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_VIEWPORT(" )
cpp_quote( "        _In_ ID3D11Texture1D* pTex1D," )
cpp_quote( "        _In_ ID3D11RenderTargetView* pRTView," )
cpp_quote( "        FLOAT topLeftX = 0.0f," )
cpp_quote( "        FLOAT minDepth = D3D11_MIN_DEPTH," )
cpp_quote( "        FLOAT maxDepth = D3D11_MAX_DEPTH )" )
cpp_quote( "    {" )
cpp_quote( "        D3D11_TEXTURE1D_DESC TexDesc;" )
cpp_quote( "        pTex1D->GetDesc( &TexDesc );" )
cpp_quote( "        D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;" )
cpp_quote( "        pRTView->GetDesc( &RTVDesc );" )
cpp_quote( "        UINT MipSlice = 0;" )
cpp_quote( "        switch (RTVDesc.ViewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            MipSlice = RTVDesc.Texture1D.MipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            MipSlice = RTVDesc.Texture1DArray.MipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "        const UINT SubResourceWidth = TexDesc.Width / (UINT( 1 ) << MipSlice);" )
cpp_quote( "        TopLeftX = topLeftX;" )
cpp_quote( "        TopLeftY = 0.0f;" )
cpp_quote( "        Width = (SubResourceWidth ? SubResourceWidth : 1) - topLeftX;" )
cpp_quote( "        Height = 1.0f;" )
cpp_quote( "        MinDepth = minDepth;" )
cpp_quote( "        MaxDepth = maxDepth;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_VIEWPORT(" )
cpp_quote( "        _In_ ID3D11Texture2D* pTex2D," )
cpp_quote( "        _In_ ID3D11RenderTargetView* pRTView," )
cpp_quote( "        FLOAT topLeftX = 0.0f," )
cpp_quote( "        FLOAT topLeftY = 0.0f," )
cpp_quote( "        FLOAT minDepth = D3D11_MIN_DEPTH," )
cpp_quote( "        FLOAT maxDepth = D3D11_MAX_DEPTH )" )
cpp_quote( "    {" )
cpp_quote( "        D3D11_TEXTURE2D_DESC TexDesc;" )
cpp_quote( "        pTex2D->GetDesc( &TexDesc );" )
cpp_quote( "        D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;" )
cpp_quote( "        pRTView->GetDesc( &RTVDesc );" )
cpp_quote( "        UINT MipSlice = 0;" )
cpp_quote( "        switch (RTVDesc.ViewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            MipSlice = RTVDesc.Texture2D.MipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            MipSlice = RTVDesc.Texture2DArray.MipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "        const UINT SubResourceWidth = TexDesc.Width / (UINT( 1 ) << MipSlice);" )
cpp_quote( "        const UINT SubResourceHeight = TexDesc.Height / (UINT( 1 ) << MipSlice);" )
cpp_quote( "        TopLeftX = topLeftX;" )
cpp_quote( "        TopLeftY = topLeftY;" )
cpp_quote( "        Width = (SubResourceWidth ? SubResourceWidth : 1) - topLeftX;" )
cpp_quote( "        Height = (SubResourceHeight ? SubResourceHeight : 1) - topLeftY;" )
cpp_quote( "        MinDepth = minDepth;" )
cpp_quote( "        MaxDepth = maxDepth;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_VIEWPORT(" )
cpp_quote( "        _In_ ID3D11Texture3D* pTex3D," )
cpp_quote( "        _In_ ID3D11RenderTargetView* pRTView," )
cpp_quote( "        FLOAT topLeftX = 0.0f," )
cpp_quote( "        FLOAT topLeftY = 0.0f," )
cpp_quote( "        FLOAT minDepth = D3D11_MIN_DEPTH," )
cpp_quote( "        FLOAT maxDepth = D3D11_MAX_DEPTH )" )
cpp_quote( "    {" )
cpp_quote( "        D3D11_TEXTURE3D_DESC TexDesc;" )
cpp_quote( "        pTex3D->GetDesc( &TexDesc );" )
cpp_quote( "        D3D11_RENDER_TARGET_VIEW_DESC RTVDesc;" )
cpp_quote( "        pRTView->GetDesc( &RTVDesc );" )
cpp_quote( "        UINT MipSlice = 0;" )
cpp_quote( "        switch (RTVDesc.ViewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_RTV_DIMENSION_TEXTURE3D:" )
cpp_quote( "            MipSlice = RTVDesc.Texture3D.MipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "        const UINT SubResourceWidth = TexDesc.Width / (UINT( 1 ) << MipSlice);" )
cpp_quote( "        const UINT SubResourceHeight = TexDesc.Height / (UINT( 1 ) << MipSlice);" )
cpp_quote( "        TopLeftX = topLeftX;" )
cpp_quote( "        TopLeftY = topLeftY;" )
cpp_quote( "        Width = (SubResourceWidth ? SubResourceWidth : 1) - topLeftX;" )
cpp_quote( "        Height = (SubResourceHeight ? SubResourceHeight : 1) - topLeftY;" )
cpp_quote( "        MinDepth = minDepth;" )
cpp_quote( "        MaxDepth = maxDepth;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_VIEWPORT() {}" )
cpp_quote( "    operator const D3D11_VIEWPORT&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// DepthStencilView
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct D3D11_TEX1D_DSV
{
    UINT MipSlice;
} D3D11_TEX1D_DSV;

typedef struct D3D11_TEX1D_ARRAY_DSV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX1D_ARRAY_DSV;

typedef struct D3D11_TEX2D_DSV
{
    UINT MipSlice;
} D3D11_TEX2D_DSV;

typedef struct D3D11_TEX2D_ARRAY_DSV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2D_ARRAY_DSV;

typedef struct D3D11_TEX2DMS_DSV
{
    UINT UnusedField_NothingToDefine;
} D3D11_TEX2DMS_DSV;

typedef struct D3D11_TEX2DMS_ARRAY_DSV
{
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2DMS_ARRAY_DSV;

typedef enum D3D11_DSV_FLAG
{
    D3D11_DSV_READ_ONLY_DEPTH = 0x1L,
    D3D11_DSV_READ_ONLY_STENCIL = 0x2L,
} D3D11_DSV_FLAG;

typedef struct D3D11_DEPTH_STENCIL_VIEW_DESC
{
    DXGI_FORMAT Format;
    D3D11_DSV_DIMENSION ViewDimension;
    UINT Flags; // D3D11_DSV_FLAG

    union
    {
        D3D11_TEX1D_DSV Texture1D;
        D3D11_TEX1D_ARRAY_DSV Texture1DArray;
        D3D11_TEX2D_DSV Texture2D;
        D3D11_TEX2D_ARRAY_DSV Texture2DArray;
        D3D11_TEX2DMS_DSV Texture2DMS;
        D3D11_TEX2DMS_ARRAY_DSV Texture2DMSArray;
    };
} D3D11_DEPTH_STENCIL_VIEW_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_DEPTH_STENCIL_VIEW_DESC : public D3D11_DEPTH_STENCIL_VIEW_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_DEPTH_STENCIL_VIEW_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_VIEW_DESC( const D3D11_DEPTH_STENCIL_VIEW_DESC& o ) :" )
cpp_quote( "        D3D11_DEPTH_STENCIL_VIEW_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_VIEW_DESC(" )
cpp_quote( "        D3D11_DSV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1," )
cpp_quote( "        UINT flags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        Flags = flags;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            Texture2DMSArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DMSArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture1D* pTex1D," )
cpp_quote( "        D3D11_DSV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1," )
cpp_quote( "        UINT flags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        Flags = flags;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format ||" )
cpp_quote( "            (-1 == arraySize && D3D11_DSV_DIMENSION_TEXTURE1DARRAY == viewDimension))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE1D_DESC TexDesc;" )
cpp_quote( "            pTex1D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_DEPTH_STENCIL_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture2D* pTex2D," )
cpp_quote( "        D3D11_DSV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1," )
cpp_quote( "        UINT flags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        Flags = flags;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || " )
cpp_quote( "            (-1 == arraySize &&" )
cpp_quote( "                (D3D11_DSV_DIMENSION_TEXTURE2DARRAY == viewDimension ||" )
cpp_quote( "                D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY == viewDimension)))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE2D_DESC TexDesc;" )
cpp_quote( "            pTex2D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2DMS:" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY:" )
cpp_quote( "            Texture2DMSArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DMSArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_DEPTH_STENCIL_VIEW_DESC() {}" )
cpp_quote( "    operator const D3D11_DEPTH_STENCIL_VIEW_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 9fdac92a-1876-48c3-afad-25b94f84a9b6 ), object, local, pointer_default( unique ) ]
interface ID3D11DepthStencilView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// UnorderedAccessView
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef enum D3D11_BUFFER_UAV_FLAG
{
    D3D11_BUFFER_UAV_FLAG_RAW =    0x00000001,
    D3D11_BUFFER_UAV_FLAG_APPEND = 0x00000002,
    D3D11_BUFFER_UAV_FLAG_COUNTER = 0x00000004,
} D3D11_BUFFER_UAV_FLAG;

typedef struct D3D11_BUFFER_UAV
{
    UINT FirstElement;
    UINT NumElements;
    UINT Flags; // See D3D11_BUFFER_UAV_FLAG_* below
} D3D11_BUFFER_UAV;

typedef struct D3D11_TEX1D_UAV
{
    UINT MipSlice;
} D3D11_TEX1D_UAV;

typedef struct D3D11_TEX1D_ARRAY_UAV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX1D_ARRAY_UAV;

typedef struct D3D11_TEX2D_UAV
{
    UINT MipSlice;
} D3D11_TEX2D_UAV;

typedef struct D3D11_TEX2D_ARRAY_UAV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2D_ARRAY_UAV;

typedef struct D3D11_TEX3D_UAV
{
    UINT MipSlice;
    UINT FirstWSlice;
    UINT WSize;
} D3D11_TEX3D_UAV;
 
typedef struct D3D11_UNORDERED_ACCESS_VIEW_DESC
{
    DXGI_FORMAT Format;
    D3D11_UAV_DIMENSION ViewDimension;

    union
    {
        D3D11_BUFFER_UAV Buffer;
        D3D11_TEX1D_UAV Texture1D;
        D3D11_TEX1D_ARRAY_UAV Texture1DArray;
        D3D11_TEX2D_UAV Texture2D;
        D3D11_TEX2D_ARRAY_UAV Texture2DArray;
        D3D11_TEX3D_UAV Texture3D;
    };
} D3D11_UNORDERED_ACCESS_VIEW_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_UNORDERED_ACCESS_VIEW_DESC : public D3D11_UNORDERED_ACCESS_VIEW_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_UNORDERED_ACCESS_VIEW_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_UNORDERED_ACCESS_VIEW_DESC( const D3D11_UNORDERED_ACCESS_VIEW_DESC& o ) :" )
cpp_quote( "        D3D11_UNORDERED_ACCESS_VIEW_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_UNORDERED_ACCESS_VIEW_DESC(" )
cpp_quote( "        D3D11_UAV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0, // FirstElement for BUFFER" )
cpp_quote( "        UINT firstArraySlice = 0, // NumElements for BUFFER, FirstWSlice for TEXTURE3D" )
cpp_quote( "        UINT arraySize = -1, // WSize for TEXTURE3D" )
cpp_quote( "        UINT flags = 0 ) // BUFFER only" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_UAV_DIMENSION_BUFFER:" )
cpp_quote( "            Buffer.FirstElement = mipSlice;" )
cpp_quote( "            Buffer.NumElements = firstArraySlice;" )
cpp_quote( "            Buffer.Flags = flags;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE3D:" )
cpp_quote( "            Texture3D.MipSlice = mipSlice;" )
cpp_quote( "            Texture3D.FirstWSlice = firstArraySlice;" )
cpp_quote( "            Texture3D.WSize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_UNORDERED_ACCESS_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Buffer*," )
cpp_quote( "        DXGI_FORMAT format," )
cpp_quote( "        UINT firstElement," )
cpp_quote( "        UINT numElements," )
cpp_quote( "        UINT flags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Format = format;" )
cpp_quote( "        ViewDimension = D3D11_UAV_DIMENSION_BUFFER;" )
cpp_quote( "        Buffer.FirstElement = firstElement;" )
cpp_quote( "        Buffer.NumElements = numElements;" )
cpp_quote( "        Buffer.Flags = flags;" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_UNORDERED_ACCESS_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture1D* pTex1D," )
cpp_quote( "        D3D11_UAV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format ||" )
cpp_quote( "            (-1 == arraySize && D3D11_UAV_DIMENSION_TEXTURE1DARRAY == viewDimension))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE1D_DESC TexDesc;" )
cpp_quote( "            pTex1D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE1D:" )
cpp_quote( "            Texture1D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE1DARRAY:" )
cpp_quote( "            Texture1DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture1DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture1DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_UNORDERED_ACCESS_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture2D* pTex2D," )
cpp_quote( "        D3D11_UAV_DIMENSION viewDimension," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstArraySlice = 0," )
cpp_quote( "        UINT arraySize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = viewDimension;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || " )
cpp_quote( "            (-1 == arraySize && D3D11_UAV_DIMENSION_TEXTURE2DARRAY == viewDimension))" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE2D_DESC TexDesc;" )
cpp_quote( "            pTex2D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == arraySize) arraySize = TexDesc.ArraySize - firstArraySlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        switch (viewDimension)" )
cpp_quote( "        {" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE2D:" )
cpp_quote( "            Texture2D.MipSlice = mipSlice;" )
cpp_quote( "            break;" )
cpp_quote( "        case D3D11_UAV_DIMENSION_TEXTURE2DARRAY:" )
cpp_quote( "            Texture2DArray.MipSlice = mipSlice;" )
cpp_quote( "            Texture2DArray.FirstArraySlice = firstArraySlice;" )
cpp_quote( "            Texture2DArray.ArraySize = arraySize;" )
cpp_quote( "            break;" )
cpp_quote( "        default: break;" )
cpp_quote( "        }" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_UNORDERED_ACCESS_VIEW_DESC(" )
cpp_quote( "        _In_ ID3D11Texture3D* pTex3D," )
cpp_quote( "        DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN," )
cpp_quote( "        UINT mipSlice = 0," )
cpp_quote( "        UINT firstWSlice = 0," )
cpp_quote( "        UINT wSize = -1 )" )
cpp_quote( "    {" )
cpp_quote( "        ViewDimension = D3D11_UAV_DIMENSION_TEXTURE3D;" )
cpp_quote( "        if (DXGI_FORMAT_UNKNOWN == format || -1 == wSize)" )
cpp_quote( "        {" )
cpp_quote( "            D3D11_TEXTURE3D_DESC TexDesc;" )
cpp_quote( "            pTex3D->GetDesc( &TexDesc );" )
cpp_quote( "            if (DXGI_FORMAT_UNKNOWN == format) format = TexDesc.Format;" )
cpp_quote( "            if (-1 == wSize) wSize = TexDesc.Depth - firstWSlice;" )
cpp_quote( "        }" )
cpp_quote( "        Format = format;" )
cpp_quote( "        Texture3D.MipSlice = mipSlice;" )
cpp_quote( "        Texture3D.FirstWSlice = firstWSlice;" )
cpp_quote( "        Texture3D.WSize = wSize;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_UNORDERED_ACCESS_VIEW_DESC() {}" )
cpp_quote( "    operator const D3D11_UNORDERED_ACCESS_VIEW_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( 28acf509-7f5c-48f6-8611-f316010a6380 ), object, local, pointer_default( unique ) ]
interface ID3D11UnorderedAccessView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Vertex Shader
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( 3b301d64-d678-4289-8897-22f8928b72f3 ), object, local, pointer_default( unique ) ]
interface ID3D11VertexShader
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Hull Shader
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( 8e5c6061-628a-4c8e-8264-bbe45cb3d5dd ), object, local, pointer_default( unique ) ]
interface ID3D11HullShader
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Domain Shader
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( f582c508-0f36-490c-9977-31eece268cfa ), object, local, pointer_default( unique ) ]
interface ID3D11DomainShader
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Geometry Shader
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( 38325b96-effb-4022-ba02-2e795b70275c ), object, local, pointer_default( unique ) ]
interface ID3D11GeometryShader
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Pixel Shader
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( ea82e40d-51dc-4f33-93d4-db7c9125ae8c ), object, local, pointer_default( unique ) ]
interface ID3D11PixelShader
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Compute Shader
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( 4f5b196e-c2bd-495e-bd01-1fded38e4969 ), object, local, pointer_default( unique ) ]
interface ID3D11ComputeShader
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// InputLayout
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( e4819ddc-4cf0-4025-bd26-5de82a3e07b7 ), object, local, pointer_default( unique ) ]
interface ID3D11InputLayout
    : ID3D11DeviceChild
{
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Sampler
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef enum D3D11_FILTER
{
    // Bits used in defining enumeration of valid filters:
    // bits [1:0] - mip: 0 == point, 1 == linear, 2,3 unused
    // bits [3:2] - mag: 0 == point, 1 == linear, 2,3 unused
    // bits [5:4] - min: 0 == point, 1 == linear, 2,3 unused
    // bit  [6]   - aniso
    // bits [8:7] - reduction type: 
    //                0 == standard filtering
    //                1 == comparison
    //                2 == min
    //                3 == max
    // bit  [31]  - mono 1-bit (narrow-purpose filter) [no longer supported in D3D11]

    D3D11_FILTER_MIN_MAG_MIP_POINT                              = 0x00000000,
    D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR                       = 0x00000001,
    D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT                 = 0x00000004,
    D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR                       = 0x00000005,
    D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT                       = 0x00000010,
    D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR                = 0x00000011,
    D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT                       = 0x00000014,
    D3D11_FILTER_MIN_MAG_MIP_LINEAR                             = 0x00000015,
    D3D11_FILTER_ANISOTROPIC                                    = 0x00000055,
    D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT                   = 0x00000080,
    D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR            = 0x00000081,
    D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT      = 0x00000084,
    D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR            = 0x00000085,
    D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT            = 0x00000090,
    D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR     = 0x00000091,
    D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT            = 0x00000094,
    D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR                  = 0x00000095,
    D3D11_FILTER_COMPARISON_ANISOTROPIC                         = 0x000000d5,
    D3D11_FILTER_MINIMUM_MIN_MAG_MIP_POINT                      = 0x00000100,
    D3D11_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR               = 0x00000101,
    D3D11_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT         = 0x00000104,
    D3D11_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR               = 0x00000105,
    D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT               = 0x00000110,
    D3D11_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR        = 0x00000111,
    D3D11_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT               = 0x00000114,
    D3D11_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR                     = 0x00000115,
    D3D11_FILTER_MINIMUM_ANISOTROPIC                            = 0x00000155,
    D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_POINT                      = 0x00000180,
    D3D11_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR               = 0x00000181,
    D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT         = 0x00000184,
    D3D11_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR               = 0x00000185,
    D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT               = 0x00000190,
    D3D11_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR        = 0x00000191,
    D3D11_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT               = 0x00000194,
    D3D11_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR                     = 0x00000195,
    D3D11_FILTER_MAXIMUM_ANISOTROPIC                            = 0x000001d5
} D3D11_FILTER;

typedef enum D3D11_FILTER_TYPE
{
    D3D11_FILTER_TYPE_POINT = 0,
    D3D11_FILTER_TYPE_LINEAR = 1,
} D3D11_FILTER_TYPE;

typedef enum D3D11_FILTER_REDUCTION_TYPE
{
    D3D11_FILTER_REDUCTION_TYPE_STANDARD = 0,
    D3D11_FILTER_REDUCTION_TYPE_COMPARISON = 1,
    D3D11_FILTER_REDUCTION_TYPE_MINIMUM = 2,
    D3D11_FILTER_REDUCTION_TYPE_MAXIMUM = 3,
} D3D11_FILTER_REDUCTION_TYPE;

const UINT D3D11_FILTER_REDUCTION_TYPE_MASK = 0x00000003;
const UINT D3D11_FILTER_REDUCTION_TYPE_SHIFT = 7;

const UINT D3D11_FILTER_TYPE_MASK = 0x00000003;
const UINT D3D11_MIN_FILTER_SHIFT = 4;
const UINT D3D11_MAG_FILTER_SHIFT = 2;
const UINT D3D11_MIP_FILTER_SHIFT = 0;

cpp_quote( "// D3D11_COMPARISON_FILTERING_BIT is no longer used / meaningless.  The D3D11_FILTER_REDUCTION_TYPE enum replaced it. " )
cpp_quote( "// Old code that uses D3D11_COMPARISON_FILTERING_BIT and would never use D3D11_FILTER_MINIMUM_* or D3D11_FILTER_MAXIMUM_* " )
cpp_quote( "// will still work fine though, so the define is left to avoid breaks. " )
const UINT D3D11_COMPARISON_FILTERING_BIT = 0x00000080;

const UINT D3D11_ANISOTROPIC_FILTERING_BIT = 0x00000040;

// encode enum entry for most filters except anisotropic filtering
cpp_quote( "#define D3D11_ENCODE_BASIC_FILTER( min, mag, mip, reduction )                                                     \\" )
cpp_quote( "                                   ( ( D3D11_FILTER ) (                                                           \\" )
cpp_quote( "                                   ( ( ( min ) & D3D11_FILTER_TYPE_MASK ) << D3D11_MIN_FILTER_SHIFT ) |           \\" )
cpp_quote( "                                   ( ( ( mag ) & D3D11_FILTER_TYPE_MASK ) << D3D11_MAG_FILTER_SHIFT ) |           \\" )
cpp_quote( "                                   ( ( ( mip ) & D3D11_FILTER_TYPE_MASK ) << D3D11_MIP_FILTER_SHIFT ) |           \\" )
cpp_quote( "                                   ( ( ( reduction ) & D3D11_FILTER_REDUCTION_TYPE_MASK ) << D3D11_FILTER_REDUCTION_TYPE_SHIFT ) ) ) " )

// encode enum entry for anisotropic filtering (with or without comparison filtering)
cpp_quote( "#define D3D11_ENCODE_ANISOTROPIC_FILTER( reduction )                                                  \\" )
cpp_quote( "                                         ( ( D3D11_FILTER ) (                                         \\" )
cpp_quote( "                                         D3D11_ANISOTROPIC_FILTERING_BIT |                            \\" )
cpp_quote( "                                         D3D11_ENCODE_BASIC_FILTER( D3D11_FILTER_TYPE_LINEAR,         \\" )
cpp_quote( "                                                                    D3D11_FILTER_TYPE_LINEAR,         \\" )
cpp_quote( "                                                                    D3D11_FILTER_TYPE_LINEAR,         \\" )
cpp_quote( "                                                                    reduction ) ) )                     " )

cpp_quote( "#define D3D11_DECODE_MIN_FILTER( d3d11Filter )                                                              \\" )
cpp_quote( "                                 ( ( D3D11_FILTER_TYPE )                                                    \\" )
cpp_quote( "                                 ( ( ( d3d11Filter ) >> D3D11_MIN_FILTER_SHIFT ) & D3D11_FILTER_TYPE_MASK ) ) " )

cpp_quote( "#define D3D11_DECODE_MAG_FILTER( d3d11Filter )                                                              \\" )
cpp_quote( "                                 ( ( D3D11_FILTER_TYPE )                                                    \\" )
cpp_quote( "                                 ( ( ( d3d11Filter ) >> D3D11_MAG_FILTER_SHIFT ) & D3D11_FILTER_TYPE_MASK ) ) " )

cpp_quote( "#define D3D11_DECODE_MIP_FILTER( d3d11Filter )                                                              \\" )
cpp_quote( "                                 ( ( D3D11_FILTER_TYPE )                                                    \\" )
cpp_quote( "                                 ( ( ( d3d11Filter ) >> D3D11_MIP_FILTER_SHIFT ) & D3D11_FILTER_TYPE_MASK ) ) " )

cpp_quote( "#define D3D11_DECODE_FILTER_REDUCTION( d3d11Filter )                                                        \\" )
cpp_quote( "                                 ( ( D3D11_FILTER_REDUCTION_TYPE )                                                      \\" )
cpp_quote( "                                 ( ( ( d3d11Filter ) >> D3D11_FILTER_REDUCTION_TYPE_SHIFT ) & D3D11_FILTER_REDUCTION_TYPE_MASK ) ) " )

cpp_quote( "#define D3D11_DECODE_IS_COMPARISON_FILTER( d3d11Filter )                                                    \\" )
cpp_quote( "                                 ( D3D11_DECODE_FILTER_REDUCTION( d3d11Filter ) == D3D11_FILTER_REDUCTION_TYPE_COMPARISON ) " )

cpp_quote( "#define D3D11_DECODE_IS_ANISOTROPIC_FILTER( d3d11Filter )                                               \\" )
cpp_quote( "                            ( ( ( d3d11Filter ) & D3D11_ANISOTROPIC_FILTERING_BIT ) &&                  \\" )
cpp_quote( "                            ( D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MIN_FILTER( d3d11Filter ) ) &&   \\" )
cpp_quote( "                            ( D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MAG_FILTER( d3d11Filter ) ) &&   \\" )
cpp_quote( "                            ( D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MIP_FILTER( d3d11Filter ) ) )      " )

typedef enum D3D11_TEXTURE_ADDRESS_MODE
{
    D3D11_TEXTURE_ADDRESS_WRAP = 1,
    D3D11_TEXTURE_ADDRESS_MIRROR = 2,
    D3D11_TEXTURE_ADDRESS_CLAMP = 3,
    D3D11_TEXTURE_ADDRESS_BORDER = 4,
    D3D11_TEXTURE_ADDRESS_MIRROR_ONCE = 5
} D3D11_TEXTURE_ADDRESS_MODE;

typedef struct D3D11_SAMPLER_DESC
{
    D3D11_FILTER Filter;
    D3D11_TEXTURE_ADDRESS_MODE AddressU;
    D3D11_TEXTURE_ADDRESS_MODE AddressV;
    D3D11_TEXTURE_ADDRESS_MODE AddressW;
    FLOAT MipLODBias;
    UINT MaxAnisotropy;
    D3D11_COMPARISON_FUNC ComparisonFunc;
    FLOAT BorderColor[4]; // RGBA
    FLOAT MinLOD;
    FLOAT MaxLOD;
} D3D11_SAMPLER_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_SAMPLER_DESC : public D3D11_SAMPLER_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_SAMPLER_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_SAMPLER_DESC( const D3D11_SAMPLER_DESC& o ) :" )
cpp_quote( "        D3D11_SAMPLER_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_SAMPLER_DESC( CD3D11_DEFAULT )" )
cpp_quote( "    {" )
cpp_quote( "        Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;" )
cpp_quote( "        AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;" )
cpp_quote( "        AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;" )
cpp_quote( "        AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;" )
cpp_quote( "        MipLODBias = 0;" )
cpp_quote( "        MaxAnisotropy = 1;" )
cpp_quote( "        ComparisonFunc = D3D11_COMPARISON_NEVER;" )
cpp_quote( "        BorderColor[ 0 ] = 1.0f;" )
cpp_quote( "        BorderColor[ 1 ] = 1.0f;" )
cpp_quote( "        BorderColor[ 2 ] = 1.0f;" )
cpp_quote( "        BorderColor[ 3 ] = 1.0f;" )
cpp_quote( "        MinLOD = -3.402823466e+38F; // -FLT_MAX" )
cpp_quote( "        MaxLOD = 3.402823466e+38F; // FLT_MAX" )
cpp_quote( "    }" )
cpp_quote( "    explicit CD3D11_SAMPLER_DESC(" )
cpp_quote( "        D3D11_FILTER filter," )
cpp_quote( "        D3D11_TEXTURE_ADDRESS_MODE addressU," )
cpp_quote( "        D3D11_TEXTURE_ADDRESS_MODE addressV," )
cpp_quote( "        D3D11_TEXTURE_ADDRESS_MODE addressW," )
cpp_quote( "        FLOAT mipLODBias," )
cpp_quote( "        UINT maxAnisotropy," )
cpp_quote( "        D3D11_COMPARISON_FUNC comparisonFunc," )
cpp_quote( "        _In_reads_opt_( 4 ) const FLOAT* borderColor, // RGBA" )
cpp_quote( "        FLOAT minLOD," )
cpp_quote( "        FLOAT maxLOD )" )
cpp_quote( "    {" )
cpp_quote( "        Filter = filter;" )
cpp_quote( "        AddressU = addressU;" )
cpp_quote( "        AddressV = addressV;" )
cpp_quote( "        AddressW = addressW;" )
cpp_quote( "        MipLODBias = mipLODBias;" )
cpp_quote( "        MaxAnisotropy = maxAnisotropy;" )
cpp_quote( "        ComparisonFunc = comparisonFunc;" )
cpp_quote( "        const float defaultColor[ 4 ] = { 1.0f, 1.0f, 1.0f, 1.0f };" )
cpp_quote( "        if (!borderColor) borderColor = defaultColor;" )
cpp_quote( "        BorderColor[ 0 ] = borderColor[ 0 ];" )
cpp_quote( "        BorderColor[ 1 ] = borderColor[ 1 ];" )
cpp_quote( "        BorderColor[ 2 ] = borderColor[ 2 ];" )
cpp_quote( "        BorderColor[ 3 ] = borderColor[ 3 ];" )
cpp_quote( "        MinLOD = minLOD;" )
cpp_quote( "        MaxLOD = maxLOD;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_SAMPLER_DESC() {}" )
cpp_quote( "    operator const D3D11_SAMPLER_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( da6fea51-564c-4487-9810-f0d0f9b4e3a5 ), object, local, pointer_default( unique ) ]
interface ID3D11SamplerState
    : ID3D11DeviceChild
{
    void GetDesc( [annotation("_Out_")] D3D11_SAMPLER_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Format Support Flags for CheckFormatSupport API
// Extended enum (and the original one) are also used in CheckFeatureSupport API (which is a superset of CheckFormatSupport).
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef enum D3D11_FORMAT_SUPPORT
{
    D3D11_FORMAT_SUPPORT_BUFFER = 0x00000001,
    D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x00000002,
    D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x00000004,
    D3D11_FORMAT_SUPPORT_SO_BUFFER = 0x00000008,
    D3D11_FORMAT_SUPPORT_TEXTURE1D = 0x00000010,
    D3D11_FORMAT_SUPPORT_TEXTURE2D = 0x00000020,
    D3D11_FORMAT_SUPPORT_TEXTURE3D = 0x00000040,
    D3D11_FORMAT_SUPPORT_TEXTURECUBE = 0x00000080,
    D3D11_FORMAT_SUPPORT_SHADER_LOAD = 0x00000100,
    D3D11_FORMAT_SUPPORT_SHADER_SAMPLE = 0x00000200,
    D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x00000400,
    D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x00000800,
    D3D11_FORMAT_SUPPORT_MIP = 0x00001000,
    D3D11_FORMAT_SUPPORT_MIP_AUTOGEN = 0x00002000,
    D3D11_FORMAT_SUPPORT_RENDER_TARGET = 0x00004000,
    D3D11_FORMAT_SUPPORT_BLENDABLE = 0x00008000,
    D3D11_FORMAT_SUPPORT_DEPTH_STENCIL = 0x00010000,
    D3D11_FORMAT_SUPPORT_CPU_LOCKABLE = 0x00020000,
    D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x00040000,
    D3D11_FORMAT_SUPPORT_DISPLAY = 0x00080000,
    D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT = 0x00100000,
    D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET = 0x00200000,
    D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD = 0x00400000,
    D3D11_FORMAT_SUPPORT_SHADER_GATHER = 0x00800000,
    D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST = 0x01000000,
    D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW = 0x02000000,
    D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON = 0x04000000,
    D3D11_FORMAT_SUPPORT_DECODER_OUTPUT = 0x08000000,
    D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT = 0x10000000,
    D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_INPUT = 0x20000000,
    D3D11_FORMAT_SUPPORT_VIDEO_ENCODER = 0x40000000,
} D3D11_FORMAT_SUPPORT;

// D3D11_FORMAT_SUPPORT2 is only used in CheckFeatureSupport
typedef enum D3D11_FORMAT_SUPPORT2
{
    D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_ADD                                    = 0x00000001,
    D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS                            = 0x00000002,
    D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE      = 0x00000004,
    D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE                               = 0x00000008,
    D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX                      = 0x00000010,
    D3D11_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX                    = 0x00000020,
    D3D11_FORMAT_SUPPORT2_UAV_TYPED_LOAD                                    = 0x00000040,
    D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE                                   = 0x00000080,
    D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP                            = 0x00000100,
    D3D11_FORMAT_SUPPORT2_TILED                                             = 0x00000200,
    D3D11_FORMAT_SUPPORT2_SHAREABLE                                         = 0x00000400,
    D3D11_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY                                = 0x00004000,
} D3D11_FORMAT_SUPPORT2;


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Query
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
[ uuid( 4b35d0cd-1e15-4258-9c98-1b1333f6dd3b ), object, local, pointer_default( unique ) ]
interface ID3D11Asynchronous
    : ID3D11DeviceChild
{
    UINT GetDataSize();
};

typedef enum D3D11_ASYNC_GETDATA_FLAG
{
        D3D11_ASYNC_GETDATA_DONOTFLUSH = 0x1,
} D3D11_ASYNC_GETDATA_FLAG;


typedef enum D3D11_QUERY
{
    D3D11_QUERY_EVENT = 0,
    D3D11_QUERY_OCCLUSION,
    D3D11_QUERY_TIMESTAMP,
    D3D11_QUERY_TIMESTAMP_DISJOINT,
    D3D11_QUERY_PIPELINE_STATISTICS,
    D3D11_QUERY_OCCLUSION_PREDICATE,
    D3D11_QUERY_SO_STATISTICS,
    D3D11_QUERY_SO_OVERFLOW_PREDICATE,
    D3D11_QUERY_SO_STATISTICS_STREAM0,
    D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0,
    D3D11_QUERY_SO_STATISTICS_STREAM1,
    D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1,
    D3D11_QUERY_SO_STATISTICS_STREAM2,
    D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2,
    D3D11_QUERY_SO_STATISTICS_STREAM3,
    D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3,
} D3D11_QUERY;

typedef enum D3D11_QUERY_MISC_FLAG
{
        D3D11_QUERY_MISC_PREDICATEHINT = 0x1,
} D3D11_QUERY_MISC_FLAG;

typedef struct D3D11_QUERY_DESC
{
    D3D11_QUERY Query;
    UINT MiscFlags;
} D3D11_QUERY_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_QUERY_DESC : public D3D11_QUERY_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_QUERY_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_QUERY_DESC( const D3D11_QUERY_DESC& o ) :" )
cpp_quote( "        D3D11_QUERY_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_QUERY_DESC(" )
cpp_quote( "        D3D11_QUERY query," )
cpp_quote( "        UINT miscFlags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Query = query;" )
cpp_quote( "        MiscFlags = miscFlags;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_QUERY_DESC() {}" )
cpp_quote( "    operator const D3D11_QUERY_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

[ uuid( d6c00747-87b7-425e-b84d-44d108560afd ), object, local, pointer_default( unique ) ]
interface ID3D11Query
    : ID3D11Asynchronous
{
    void GetDesc( [annotation("_Out_")] D3D11_QUERY_DESC* pDesc );
};

[ uuid( 9eb576dd-9f77-4d86-81aa-8bab5fe490e2 ), object, local, pointer_default( unique ) ]
interface ID3D11Predicate
    : ID3D11Query
{
};

typedef struct D3D11_QUERY_DATA_TIMESTAMP_DISJOINT
{
    UINT64 Frequency;
    BOOL Disjoint;
} D3D11_QUERY_DATA_TIMESTAMP_DISJOINT;

typedef struct D3D11_QUERY_DATA_PIPELINE_STATISTICS
{
    UINT64 IAVertices;
    UINT64 IAPrimitives;
    UINT64 VSInvocations;
    UINT64 GSInvocations;
    UINT64 GSPrimitives;
    UINT64 CInvocations;
    UINT64 CPrimitives;
    UINT64 PSInvocations;
    UINT64 HSInvocations;
    UINT64 DSInvocations;
    UINT64 CSInvocations;
} D3D11_QUERY_DATA_PIPELINE_STATISTICS;

typedef struct D3D11_QUERY_DATA_SO_STATISTICS
{
    UINT64 NumPrimitivesWritten;
    UINT64 PrimitivesStorageNeeded;
} D3D11_QUERY_DATA_SO_STATISTICS;

typedef enum D3D11_COUNTER
{
    D3D11_COUNTER_DEVICE_DEPENDENT_0 = 0x40000000, // DO NOT define any more D3D11_COUNTER values after this.
} D3D11_COUNTER;

typedef enum D3D11_COUNTER_TYPE
{
    D3D11_COUNTER_TYPE_FLOAT32,
    D3D11_COUNTER_TYPE_UINT16,
    D3D11_COUNTER_TYPE_UINT32,
    D3D11_COUNTER_TYPE_UINT64,
} D3D11_COUNTER_TYPE;

typedef struct D3D11_COUNTER_DESC
{
    D3D11_COUNTER Counter;
    UINT MiscFlags;
} D3D11_COUNTER_DESC;

cpp_quote( "#if !defined( D3D11_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_COUNTER_DESC : public D3D11_COUNTER_DESC" )
cpp_quote( "{" )
cpp_quote( "    CD3D11_COUNTER_DESC()" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_COUNTER_DESC( const D3D11_COUNTER_DESC& o ) :" )
cpp_quote( "        D3D11_COUNTER_DESC( o )" )
cpp_quote( "    {}" )
cpp_quote( "    explicit CD3D11_COUNTER_DESC(" )
cpp_quote( "        D3D11_COUNTER counter," )
cpp_quote( "        UINT miscFlags = 0 )" )
cpp_quote( "    {" )
cpp_quote( "        Counter = counter;" )
cpp_quote( "        MiscFlags = miscFlags;" )
cpp_quote( "    }" )
cpp_quote( "    ~CD3D11_COUNTER_DESC() {}" )
cpp_quote( "    operator const D3D11_COUNTER_DESC&() const { return *this; }" )
cpp_quote( "};" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )


typedef struct D3D11_COUNTER_INFO
{
    D3D11_COUNTER LastDeviceDependentCounter;
    UINT NumSimultaneousCounters;
    UINT8 NumDetectableParallelUnits;
} D3D11_COUNTER_INFO;

[ uuid( 6e8c49fb-a371-4770-b440-29086022b741 ), object, local, pointer_default( unique ) ]
interface ID3D11Counter
    : ID3D11Asynchronous
{
    void GetDesc( [annotation("_Out_")] D3D11_COUNTER_DESC* pDesc );
};

typedef enum D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS
{
    D3D11_STANDARD_MULTISAMPLE_PATTERN = 0xffffffff,
    D3D11_CENTER_MULTISAMPLE_PATTERN = 0xfffffffe
} D3D11_STANDARD_MULTISAMPLE_QUALITY_LEVELS;

typedef enum D3D11_DEVICE_CONTEXT_TYPE
{
    D3D11_DEVICE_CONTEXT_IMMEDIATE,
    D3D11_DEVICE_CONTEXT_DEFERRED,
} D3D11_DEVICE_CONTEXT_TYPE;

typedef struct D3D11_CLASS_INSTANCE_DESC
{
    // the first two entries are valid if the instance was created using GetClassInstance
    UINT InstanceId;
    UINT InstanceIndex; // entry in an array of instances
    // the rest of the entries are valid for instances created with CreateClassInstance
    UINT TypeId;
    UINT ConstantBuffer;
    UINT BaseConstantBufferOffset;
    UINT BaseTexture;
    UINT BaseSampler;
    // this lets you know which of the two an instance is
    BOOL Created;
} D3D11_CLASS_INSTANCE_DESC;

[ uuid( a6cd7faa-b0b7-4a2f-9436-8662a65797cb ), object, local, pointer_default( unique ) ]
interface ID3D11ClassInstance
    : ID3D11DeviceChild
{
    void GetClassLinkage(
        [annotation("_Outptr_")] ID3D11ClassLinkage** ppLinkage);
    void GetDesc(
        [annotation("_Out_")] D3D11_CLASS_INSTANCE_DESC* pDesc);
    void GetInstanceName(
        [annotation("_Out_writes_opt_(*pBufferLength)")] LPSTR pInstanceName,
        [annotation("_Inout_")] SIZE_T* pBufferLength);
    void GetTypeName(
        [annotation("_Out_writes_opt_(*pBufferLength)")] LPSTR pTypeName,
        [annotation("_Inout_")] SIZE_T* pBufferLength);
};

[ uuid( ddf57cba-9543-46e4-a12b-f207a0fe7fed ), object, local, pointer_default( unique ) ]
interface ID3D11ClassLinkage
    : ID3D11DeviceChild
{
    // Get a reference to an instance of a class
    // that exists in a shader.  The common scenario is to refer to
    // variables declared in shaders, which means that a reference is
    // acquired with this function and then passed in on SetShader.
    HRESULT GetClassInstance(
        [annotation("_In_")] LPCSTR pClassInstanceName,
        [annotation("_In_")] UINT InstanceIndex,
        [annotation("_COM_Outptr_")] ID3D11ClassInstance** ppInstance);

    // Create a class instance reference that is the combination of a class
    // type and the location of the data to use for the class instance
    // - not the common scenario, but useful in case the data location
    // for a class is dynamic or not known until runtime.
    HRESULT CreateClassInstance(
        [annotation("_In_")] LPCSTR pClassTypeName,
        [annotation("_In_")] UINT ConstantBufferOffset,
        [annotation("_In_")] UINT ConstantVectorOffset,
        [annotation("_In_")] UINT TextureOffset,
        [annotation("_In_")] UINT SamplerOffset,
        [annotation("_COM_Outptr_")] ID3D11ClassInstance** ppInstance);
};

[ uuid( a24bc4d1-769e-43f7-8013-98ff566c18e2 ), object, local, pointer_default( unique ) ]
interface ID3D11CommandList
    : ID3D11DeviceChild
{
    UINT GetContextFlags();
};

typedef enum D3D11_FEATURE
{
    D3D11_FEATURE_THREADING, /* D3D11_FEATURE_DATA_THREADING */
    D3D11_FEATURE_DOUBLES,  /* D3D11_FEATURE_DATA_DOUBLES */
    D3D11_FEATURE_FORMAT_SUPPORT, /* D3D11_FEATURE_DATA_FORMAT_SUPPORT */
    D3D11_FEATURE_FORMAT_SUPPORT2, /* D3D11_FEATURE_DATA_FORMAT_SUPPORT2 */
    D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, /* D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS */
    D3D11_FEATURE_D3D11_OPTIONS, /* D3D11_FEATURE_DATA_D3D11_OPTIONS */
    D3D11_FEATURE_ARCHITECTURE_INFO, /* D3D11_FEATURE_DATA_ARCHITECTURE_INFO */
    D3D11_FEATURE_D3D9_OPTIONS, /* D3D11_FEATURE_DATA_D3D9_OPTIONS */
    D3D11_FEATURE_SHADER_MIN_PRECISION_SUPPORT, /* D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT */
    D3D11_FEATURE_D3D9_SHADOW_SUPPORT, /* D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT */
    D3D11_FEATURE_D3D11_OPTIONS1, /* D3D11_FEATURE_D3D11_OPTIONS1 */
    D3D11_FEATURE_D3D9_SIMPLE_INSTANCING_SUPPORT, /* D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT */
    D3D11_FEATURE_MARKER_SUPPORT, /* D3D11_FEATURE_DATA_MARKER_SUPPORT */
    D3D11_FEATURE_D3D9_OPTIONS1, /* D3D11_FEATURE_DATA_D3D9_OPTIONS1 */
    D3D11_FEATURE_D3D11_OPTIONS2, /* D3D11_FEATURE_DATA_D3D11_OPTIONS2 */
    D3D11_FEATURE_D3D11_OPTIONS3, /* D3D11_FEATURE_DATA_D3D11_OPTIONS3 */
} D3D11_FEATURE;

typedef struct D3D11_FEATURE_DATA_THREADING
{
    BOOL DriverConcurrentCreates;
    BOOL DriverCommandLists;
} D3D11_FEATURE_DATA_THREADING;

typedef struct D3D11_FEATURE_DATA_DOUBLES
{
    BOOL DoublePrecisionFloatShaderOps;
} D3D11_FEATURE_DATA_DOUBLES;

typedef struct D3D11_FEATURE_DATA_FORMAT_SUPPORT
{
    DXGI_FORMAT InFormat;
    UINT OutFormatSupport;
} D3D11_FEATURE_DATA_FORMAT_SUPPORT;

typedef struct D3D11_FEATURE_DATA_FORMAT_SUPPORT2
{
    DXGI_FORMAT InFormat;
    UINT OutFormatSupport2;
} D3D11_FEATURE_DATA_FORMAT_SUPPORT2;

typedef struct D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS
{
    BOOL ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x;
} D3D11_FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS;


cpp_quote( "// =============================================================================" )
cpp_quote( "// In the D3D11_FEATURE_DATA_D3D11_OPTIONS struct below, " )
cpp_quote( "// the following groupings of capabilities will always be set identically. " )
cpp_quote( "// That is, all the BOOLs in a grouping will be TRUE or FALSE together. " )
cpp_quote( "//  " )
cpp_quote( "// Group: DiscardAPIsSeenByDriver, FlagsForUpdateAndCopySeenByDriver " )
cpp_quote( "//  " )
cpp_quote( "// Group: ClearView, CopyWithOverlap, ConstantBufferPartialUpdate " )
cpp_quote( "//        ConstantBufferOffsetting, MapNoOverwriteOnDynamicConstantBuffer " )
cpp_quote( "//  " )
cpp_quote( "// Group: MapNoOverwriteOnDynamicBufferSRV, ")
cpp_quote( "//        MultisampleRTVWithForcedSampleCountOne " )
cpp_quote( "//  " )
typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS
{
    BOOL OutputMergerLogicOp;
    BOOL UAVOnlyRenderingForcedSampleCount;

    BOOL DiscardAPIsSeenByDriver;
    BOOL FlagsForUpdateAndCopySeenByDriver;

    BOOL ClearView;
    BOOL CopyWithOverlap;
    BOOL ConstantBufferPartialUpdate;
    BOOL ConstantBufferOffsetting;
    BOOL MapNoOverwriteOnDynamicConstantBuffer;

    BOOL MapNoOverwriteOnDynamicBufferSRV;
    BOOL MultisampleRTVWithForcedSampleCountOne;

    BOOL SAD4ShaderInstructions;
    BOOL ExtendedDoublesShaderInstructions; 

    BOOL ExtendedResourceSharing;
} D3D11_FEATURE_DATA_D3D11_OPTIONS;

typedef struct D3D11_FEATURE_DATA_ARCHITECTURE_INFO
{
    BOOL TileBasedDeferredRenderer;
} D3D11_FEATURE_DATA_ARCHITECTURE_INFO;

typedef struct D3D11_FEATURE_DATA_D3D9_OPTIONS
{
    BOOL FullNonPow2TextureSupport;
} D3D11_FEATURE_DATA_D3D9_OPTIONS;

typedef struct D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT
{
    BOOL SupportsDepthAsTextureWithLessEqualComparisonFilter;
} D3D11_FEATURE_DATA_D3D9_SHADOW_SUPPORT;

typedef enum D3D11_SHADER_MIN_PRECISION_SUPPORT
{
    D3D11_SHADER_MIN_PRECISION_10_BIT = 0x1,
    D3D11_SHADER_MIN_PRECISION_16_BIT = 0x2
} D3D11_SHADER_MIN_PRECISION_SUPPORT;

typedef struct D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT
{
    UINT PixelShaderMinPrecision; // D3D11_SHADER_MIN_PRECISION_SUPPORT flags for PS
    UINT AllOtherShaderStagesMinPrecision; // D3D11_SHADER_MIN_PRECISION_SUPPORT flags for other stages
} D3D11_FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT;

typedef enum D3D11_TILED_RESOURCES_TIER
{
    D3D11_TILED_RESOURCES_NOT_SUPPORTED = 0,
    D3D11_TILED_RESOURCES_TIER_1 = 1,
    D3D11_TILED_RESOURCES_TIER_2 = 2,
    D3D11_TILED_RESOURCES_TIER_3 = 3,
} D3D11_TILED_RESOURCES_TIER;

typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS1
{
    D3D11_TILED_RESOURCES_TIER TiledResourcesTier;
    BOOL MinMaxFiltering;
    BOOL ClearViewAlsoSupportsDepthOnlyFormats;
    BOOL MapOnDefaultBuffers;
} D3D11_FEATURE_DATA_D3D11_OPTIONS1;

typedef struct D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT
{
    BOOL SimpleInstancingSupported;
} D3D11_FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT;

typedef struct D3D11_FEATURE_DATA_MARKER_SUPPORT
{
    BOOL Profile;
} D3D11_FEATURE_DATA_MARKER_SUPPORT;

typedef struct D3D11_FEATURE_DATA_D3D9_OPTIONS1
{
    BOOL FullNonPow2TextureSupported;
    BOOL DepthAsTextureWithLessEqualComparisonFilterSupported;
    BOOL SimpleInstancingSupported;
    BOOL TextureCubeFaceRenderTargetWithNonCubeDepthStencilSupported;
} D3D11_FEATURE_DATA_D3D9_OPTIONS1;

typedef enum D3D11_CONSERVATIVE_RASTERIZATION_TIER { 
  D3D11_CONSERVATIVE_RASTERIZATION_NOT_SUPPORTED  = 0,
  D3D11_CONSERVATIVE_RASTERIZATION_TIER_1         = 1,
  D3D11_CONSERVATIVE_RASTERIZATION_TIER_2         = 2,
  D3D11_CONSERVATIVE_RASTERIZATION_TIER_3         = 3,
} D3D11_CONSERVATIVE_RASTERIZATION_TIER;


typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS2
{    
    BOOL PSSpecifiedStencilRefSupported;
    BOOL TypedUAVLoadAdditionalFormats;
    BOOL ROVsSupported;
    D3D11_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier;
    D3D11_TILED_RESOURCES_TIER TiledResourcesTier;
    BOOL MapOnDefaultTextures;
    BOOL StandardSwizzle;
    BOOL UnifiedMemoryArchitecture;
} D3D11_FEATURE_DATA_D3D11_OPTIONS2;


typedef struct D3D11_FEATURE_DATA_D3D11_OPTIONS3
{    
    BOOL VPAndRTArrayIndexFromAnyShaderFeedingRasterizer;
} D3D11_FEATURE_DATA_D3D11_OPTIONS3;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// DeviceContext
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[ uuid( c0bfa96c-e089-44fb-8eaf-26f8796190da ), object, local, pointer_default( unique ) ]
interface ID3D11DeviceContext
    : ID3D11DeviceChild
{
    // !!! Order of functions is in decreasing order of priority ( as far as performance is concerned ) !!!
    // !!! BEGIN HIGH-FREQUENCY !!!
    void VSSetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppConstantBuffers );
    void PSSetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11ShaderResourceView*const* ppShaderResourceViews );
    void PSSetShader(
        [annotation("_In_opt_")] ID3D11PixelShader* pPixelShader,
        [annotation("_In_reads_opt_(NumClassInstances)")] ID3D11ClassInstance*const* ppClassInstances,
        UINT NumClassInstances );
    void PSSetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_In_reads_opt_(NumSamplers)")] ID3D11SamplerState*const* ppSamplers );
    void VSSetShader(
        [annotation("_In_opt_")] ID3D11VertexShader* pVertexShader,
        [annotation("_In_reads_opt_(NumClassInstances)")] ID3D11ClassInstance*const* ppClassInstances,
        UINT NumClassInstances );
    void DrawIndexed(
        [annotation("_In_")] UINT IndexCount,
        [annotation("_In_")] UINT StartIndexLocation,
        [annotation("_In_")] INT BaseVertexLocation );
    void Draw(
        [annotation("_In_")] UINT VertexCount,
        [annotation("_In_")] UINT StartVertexLocation );
    HRESULT Map(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_")] UINT Subresource,
        [annotation("_In_")] D3D11_MAP MapType,
        [annotation("_In_")] UINT MapFlags,
        [annotation("_Out_opt_")] D3D11_MAPPED_SUBRESOURCE* pMappedResource );
    void Unmap(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_")] UINT Subresource );
    void PSSetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppConstantBuffers );
    void IASetInputLayout( [annotation("_In_opt_")] ID3D11InputLayout* pInputLayout );
    void IASetVertexBuffers(
        [annotation("_In_range_( 0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppVertexBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] const UINT* pStrides,
        [annotation("_In_reads_opt_(NumBuffers)")] const UINT* pOffsets );
    void IASetIndexBuffer(
        [annotation("_In_opt_")] ID3D11Buffer* pIndexBuffer,
        [annotation("_In_")] DXGI_FORMAT  Format,
        [annotation("_In_")] UINT Offset );
    // !!! END HIGH-FREQUENCY !!!

    // !!! Order of functions is in decreasing order of priority ( as far as performance is concerned ) !!!
    // !!! BEGIN MIDDLE-FREQUENCY !!!
    void DrawIndexedInstanced(
        [annotation("_In_")] UINT IndexCountPerInstance,
        [annotation("_In_")] UINT InstanceCount,
        [annotation("_In_")] UINT StartIndexLocation,
        [annotation("_In_")] INT BaseVertexLocation,
        [annotation("_In_")] UINT StartInstanceLocation );
    void DrawInstanced(
        [annotation("_In_")] UINT VertexCountPerInstance,
        [annotation("_In_")] UINT InstanceCount,
        [annotation("_In_")] UINT StartVertexLocation,
        [annotation("_In_")] UINT StartInstanceLocation );
    void GSSetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppConstantBuffers );
    void GSSetShader(
        [annotation("_In_opt_")] ID3D11GeometryShader* pShader,
        [annotation("_In_reads_opt_(NumClassInstances)")] ID3D11ClassInstance*const* ppClassInstances,
        UINT NumClassInstances );
    void IASetPrimitiveTopology( [annotation("_In_")] D3D11_PRIMITIVE_TOPOLOGY Topology );
    void VSSetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11ShaderResourceView*const* ppShaderResourceViews );
    void VSSetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_In_reads_opt_(NumSamplers)")] ID3D11SamplerState*const* ppSamplers );
    void Begin( [annotation("_In_")] ID3D11Asynchronous* pAsync );
    void End( [annotation("_In_")] ID3D11Asynchronous* pAsync );
    HRESULT GetData(
        [annotation("_In_")] ID3D11Asynchronous* pAsync,
        [annotation("_Out_writes_bytes_opt_( DataSize )")] void* pData,
        [annotation("_In_")] UINT DataSize,
        [annotation("_In_")] UINT GetDataFlags );
    void SetPredication(
        [annotation("_In_opt_")] ID3D11Predicate* pPredicate,
        [annotation("_In_")] BOOL PredicateValue );
    void GSSetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11ShaderResourceView*const* ppShaderResourceViews );
    void GSSetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_In_reads_opt_(NumSamplers)")] ID3D11SamplerState*const* ppSamplers );
    void OMSetRenderTargets(
        [annotation("_In_range_( 0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11RenderTargetView*const* ppRenderTargetViews,
        [annotation("_In_opt_")] ID3D11DepthStencilView* pDepthStencilView );
    void OMSetRenderTargetsAndUnorderedAccessViews(
        [annotation("_In_")] UINT NumRTVs,
        [annotation("_In_reads_opt_(NumRTVs)")] ID3D11RenderTargetView*const* ppRenderTargetViews,
        [annotation("_In_opt_")] ID3D11DepthStencilView* pDepthStencilView,
        [annotation("_In_range_( 0, D3D11_1_UAV_SLOT_COUNT - 1 )")] UINT UAVStartSlot,
        [annotation("_In_")] UINT NumUAVs,
        [annotation("_In_reads_opt_(NumUAVs)")] ID3D11UnorderedAccessView*const* ppUnorderedAccessViews,
        [annotation("_In_reads_opt_(NumUAVs)")] const UINT* pUAVInitialCounts );
    void OMSetBlendState( 
        [annotation("_In_opt_")] ID3D11BlendState *pBlendState,
        [annotation("_In_opt_")] const FLOAT BlendFactor[ 4 ],
        [annotation("_In_")] UINT SampleMask );
    void OMSetDepthStencilState( 
        [annotation("_In_opt_")] ID3D11DepthStencilState* pDepthStencilState,
        [annotation("_In_")] UINT StencilRef );
    void SOSetTargets(
        [annotation("_In_range_( 0, D3D11_SO_BUFFER_SLOT_COUNT)")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppSOTargets,
        [annotation("_In_reads_opt_(NumBuffers)")] const UINT* pOffsets );
    void DrawAuto();
    void DrawIndexedInstancedIndirect(
        [annotation("_In_")] ID3D11Buffer* pBufferForArgs,
        [annotation("_In_")] UINT AlignedByteOffsetForArgs );
    void DrawInstancedIndirect(
        [annotation("_In_")] ID3D11Buffer* pBufferForArgs,
        [annotation("_In_")] UINT AlignedByteOffsetForArgs );
    void Dispatch(
        [annotation("_In_")] UINT ThreadGroupCountX,
        [annotation("_In_")] UINT ThreadGroupCountY,
        [annotation("_In_")] UINT ThreadGroupCountZ );
    void DispatchIndirect(
        [annotation("_In_")] ID3D11Buffer* pBufferForArgs,
        [annotation("_In_")] UINT AlignedByteOffsetForArgs );
    void RSSetState( [annotation("_In_opt_")] ID3D11RasterizerState* pRasterizerState );
    void RSSetViewports(
        [annotation("_In_range_(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)")] UINT NumViewports,
        [annotation("_In_reads_opt_(NumViewports)")] const D3D11_VIEWPORT* pViewports );
    void RSSetScissorRects(
        [annotation("_In_range_(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE)")] UINT NumRects,
        [annotation("_In_reads_opt_(NumRects)")] const D3D11_RECT* pRects );
    void CopySubresourceRegion(
        [annotation("_In_")] ID3D11Resource* pDstResource,
        [annotation("_In_")] UINT DstSubresource,
        [annotation("_In_")] UINT DstX,
        [annotation("_In_")] UINT DstY,
        [annotation("_In_")] UINT DstZ,
        [annotation("_In_")] ID3D11Resource* pSrcResource,
        [annotation("_In_")] UINT SrcSubresource,
        [annotation("_In_opt_")] const D3D11_BOX* pSrcBox );
    void CopyResource(
        [annotation("_In_")] ID3D11Resource* pDstResource,
        [annotation("_In_")] ID3D11Resource* pSrcResource );
    void UpdateSubresource(
        [annotation("_In_")] ID3D11Resource* pDstResource,
        [annotation("_In_")] UINT DstSubresource,
        [annotation("_In_opt_")] const D3D11_BOX* pDstBox,
        [annotation("_In_")] const void* pSrcData,
        [annotation("_In_")] UINT SrcRowPitch,
        [annotation("_In_")] UINT SrcDepthPitch );
    void CopyStructureCount(
        [annotation("_In_")] ID3D11Buffer* pDstBuffer,
        [annotation("_In_")] UINT DstAlignedByteOffset,
        [annotation("_In_")] ID3D11UnorderedAccessView* pSrcView );
    void ClearRenderTargetView(
        [annotation("_In_")] ID3D11RenderTargetView* pRenderTargetView,
        [annotation("_In_")] const FLOAT ColorRGBA[ 4 ] );
    void ClearUnorderedAccessViewUint(
        [annotation("_In_")] ID3D11UnorderedAccessView* pUnorderedAccessView,
        [annotation("_In_")] const UINT Values[4] );
    void ClearUnorderedAccessViewFloat(
        [annotation("_In_")] ID3D11UnorderedAccessView* pUnorderedAccessView,
        [annotation("_In_")] const FLOAT Values[4] );
    void ClearDepthStencilView(
        [annotation("_In_")] ID3D11DepthStencilView* pDepthStencilView,
        [annotation("_In_")] UINT ClearFlags,
        [annotation("_In_")] FLOAT Depth,
        [annotation("_In_")] UINT8 Stencil );
    void GenerateMips( [annotation("_In_")] ID3D11ShaderResourceView* pShaderResourceView );
    void SetResourceMinLOD( [annotation("_In_")] ID3D11Resource* pResource, FLOAT MinLOD );
    FLOAT GetResourceMinLOD( [annotation("_In_")] ID3D11Resource* pResource );
    void ResolveSubresource(
        [annotation("_In_")] ID3D11Resource* pDstResource,
        [annotation("_In_")] UINT DstSubresource,
        [annotation("_In_")] ID3D11Resource* pSrcResource,
        [annotation("_In_")] UINT SrcSubresource,
        [annotation("_In_")] DXGI_FORMAT Format );
    void ExecuteCommandList(
        [annotation("_In_")] ID3D11CommandList* pCommandList,
        BOOL RestoreContextState );
    void HSSetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11ShaderResourceView*const* ppShaderResourceViews );
    void HSSetShader(
        [annotation("_In_opt_")] ID3D11HullShader* pHullShader,
        [annotation("_In_reads_opt_(NumClassInstances)")] ID3D11ClassInstance*const* ppClassInstances,
        UINT NumClassInstances );
    void HSSetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_In_reads_opt_(NumSamplers)")] ID3D11SamplerState*const* ppSamplers );
    void HSSetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppConstantBuffers );
    void DSSetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11ShaderResourceView*const* ppShaderResourceViews );
    void DSSetShader(
        [annotation("_In_opt_")] ID3D11DomainShader* pDomainShader,
        [annotation("_In_reads_opt_(NumClassInstances)")] ID3D11ClassInstance*const* ppClassInstances,
        UINT NumClassInstances );
    void DSSetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_In_reads_opt_(NumSamplers)")] ID3D11SamplerState*const* ppSamplers );
    void DSSetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppConstantBuffers );
    void CSSetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_In_reads_opt_(NumViews)")] ID3D11ShaderResourceView*const* ppShaderResourceViews );
    void CSSetUnorderedAccessViews(
        [annotation("_In_range_( 0, D3D11_1_UAV_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_1_UAV_SLOT_COUNT - StartSlot )")] UINT NumUAVs,
        [annotation("_In_reads_opt_(NumUAVs)")] ID3D11UnorderedAccessView*const* ppUnorderedAccessViews,
        [annotation("_In_reads_opt_(NumUAVs)")] const UINT* pUAVInitialCounts );
    void CSSetShader(
        [annotation("_In_opt_")] ID3D11ComputeShader* pComputeShader,
        [annotation("_In_reads_opt_(NumClassInstances)")] ID3D11ClassInstance*const* ppClassInstances,
        UINT NumClassInstances );
    void CSSetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_In_reads_opt_(NumSamplers)")] ID3D11SamplerState*const* ppSamplers );
    void CSSetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_In_reads_opt_(NumBuffers)")] ID3D11Buffer*const* ppConstantBuffers );

// GET functions
    void VSGetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppConstantBuffers );
    void PSGetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11ShaderResourceView** ppShaderResourceViews );
    void PSGetShader(
        [annotation("_Outptr_result_maybenull_")] ID3D11PixelShader** ppPixelShader,
        [annotation("_Out_writes_opt_(*pNumClassInstances)")] ID3D11ClassInstance** ppClassInstances,
        [annotation("_Inout_opt_")] UINT* pNumClassInstances);
    void PSGetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_Out_writes_opt_(NumSamplers)")] ID3D11SamplerState** ppSamplers );
    void VSGetShader(
        [annotation("_Outptr_result_maybenull_")] ID3D11VertexShader** ppVertexShader,
        [annotation("_Out_writes_opt_(*pNumClassInstances)")] ID3D11ClassInstance** ppClassInstances,
        [annotation("_Inout_opt_")] UINT* pNumClassInstances);
    void PSGetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppConstantBuffers );
    void IAGetInputLayout( [annotation("_Outptr_result_maybenull_")] ID3D11InputLayout** ppInputLayout );
    void IAGetVertexBuffers(
        [annotation("_In_range_( 0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppVertexBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] UINT* pStrides,
        [annotation("_Out_writes_opt_(NumBuffers)")] UINT* pOffsets );
    void IAGetIndexBuffer(
        [annotation("_Outptr_opt_result_maybenull_")] ID3D11Buffer** pIndexBuffer,
        [annotation("_Out_opt_")] DXGI_FORMAT* Format,
        [annotation("_Out_opt_")] UINT* Offset );
    void GSGetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppConstantBuffers );
    void GSGetShader(
        [annotation("_Outptr_result_maybenull_")] ID3D11GeometryShader** ppGeometryShader,
        [annotation("_Out_writes_opt_(*pNumClassInstances)")] ID3D11ClassInstance** ppClassInstances,
        [annotation("_Inout_opt_")] UINT* pNumClassInstances);
    void IAGetPrimitiveTopology( [annotation("_Out_")] D3D11_PRIMITIVE_TOPOLOGY* pTopology );
    void VSGetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11ShaderResourceView** ppShaderResourceViews );
    void VSGetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_Out_writes_opt_(NumSamplers)")] ID3D11SamplerState** ppSamplers );
    void GetPredication(
        [annotation("_Outptr_opt_result_maybenull_")] ID3D11Predicate** ppPredicate,
        [annotation("_Out_opt_")] BOOL* pPredicateValue );
    void GSGetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11ShaderResourceView** ppShaderResourceViews );
    void GSGetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_Out_writes_opt_(NumSamplers)")] ID3D11SamplerState** ppSamplers );
    void OMGetRenderTargets(
        [annotation("_In_range_( 0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11RenderTargetView** ppRenderTargetViews,
        [annotation("_Outptr_opt_result_maybenull_")] ID3D11DepthStencilView** ppDepthStencilView );
    void OMGetRenderTargetsAndUnorderedAccessViews(
        [annotation("_In_range_( 0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT )")] UINT NumRTVs,
        [annotation("_Out_writes_opt_(NumRTVs)")] ID3D11RenderTargetView** ppRenderTargetViews,
        [annotation("_Outptr_opt_result_maybenull_")] ID3D11DepthStencilView** ppDepthStencilView,
        [annotation("_In_range_( 0, D3D11_PS_CS_UAV_REGISTER_COUNT - 1 )")] UINT UAVStartSlot,
        [annotation("_In_range_( 0, D3D11_PS_CS_UAV_REGISTER_COUNT - UAVStartSlot )")] UINT NumUAVs,
        [annotation("_Out_writes_opt_(NumUAVs)")] ID3D11UnorderedAccessView** ppUnorderedAccessViews );
    void OMGetBlendState( 
        [annotation("_Outptr_opt_result_maybenull_")] ID3D11BlendState** ppBlendState,
        [annotation("_Out_opt_")] FLOAT BlendFactor[ 4 ], //4
        [annotation("_Out_opt_")] UINT* pSampleMask);
    void OMGetDepthStencilState(
        [annotation("_Outptr_opt_result_maybenull_")] ID3D11DepthStencilState** ppDepthStencilState,
        [annotation("_Out_opt_")] UINT* pStencilRef );
    void SOGetTargets(
        [annotation("_In_range_( 0, D3D11_SO_BUFFER_SLOT_COUNT )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppSOTargets );
    void RSGetState( [annotation("_Outptr_result_maybenull_")] ID3D11RasterizerState** ppRasterizerState );
    void RSGetViewports(
        [annotation("_Inout_ /*_range(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE )*/ ")] UINT* pNumViewports,
        [annotation("_Out_writes_opt_(*pNumViewports)")] D3D11_VIEWPORT* pViewports );
    void RSGetScissorRects(
        [annotation("_Inout_ /*_range(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE )*/ ")] UINT* pNumRects,
        [annotation("_Out_writes_opt_(*pNumRects)")] D3D11_RECT* pRects );
    void HSGetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11ShaderResourceView** ppShaderResourceViews );
    void HSGetShader(
        [annotation("_Outptr_result_maybenull_")] ID3D11HullShader** ppHullShader,
        [annotation("_Out_writes_opt_(*pNumClassInstances)")] ID3D11ClassInstance** ppClassInstances,
        [annotation("_Inout_opt_")] UINT* pNumClassInstances);
    void HSGetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_Out_writes_opt_(NumSamplers)")] ID3D11SamplerState** ppSamplers );
    void HSGetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppConstantBuffers );
    void DSGetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11ShaderResourceView** ppShaderResourceViews );
    void DSGetShader(
        [annotation("_Outptr_result_maybenull_")] ID3D11DomainShader** ppDomainShader,
        [annotation("_Out_writes_opt_(*pNumClassInstances)")] ID3D11ClassInstance** ppClassInstances,
        [annotation("_Inout_opt_")] UINT* pNumClassInstances);
    void DSGetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_Out_writes_opt_(NumSamplers)")] ID3D11SamplerState** ppSamplers );
    void DSGetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppConstantBuffers );
    void CSGetShaderResources(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot )")] UINT NumViews,
        [annotation("_Out_writes_opt_(NumViews)")] ID3D11ShaderResourceView** ppShaderResourceViews );
    void CSGetUnorderedAccessViews(
        [annotation("_In_range_( 0, D3D11_1_UAV_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_1_UAV_SLOT_COUNT - StartSlot )")] UINT NumUAVs,
        [annotation("_Out_writes_opt_(NumUAVs)")] ID3D11UnorderedAccessView** ppUnorderedAccessViews );
    void CSGetShader(
        [annotation("_Outptr_result_maybenull_")] ID3D11ComputeShader** ppComputeShader,
        [annotation("_Out_writes_opt_(*pNumClassInstances)")] ID3D11ClassInstance** ppClassInstances,
        [annotation("_Inout_opt_")] UINT* pNumClassInstances);
    void CSGetSamplers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot )")] UINT NumSamplers,
        [annotation("_Out_writes_opt_(NumSamplers)")] ID3D11SamplerState** ppSamplers );
    void CSGetConstantBuffers(
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1 )")] UINT StartSlot,
        [annotation("_In_range_( 0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot )")] UINT NumBuffers,
        [annotation("_Out_writes_opt_(NumBuffers)")] ID3D11Buffer** ppConstantBuffers );
// /GET functions

    void ClearState();
    void Flush();
    // !!! END MIDDLE-FREQUENCY !!!

    // !!! Order of functions is in decreasing order of priority ( as far as performance is concerned ) !!!
    // !!! BEGIN LOW-FREQUENCY !!!
    D3D11_DEVICE_CONTEXT_TYPE GetType();
    UINT GetContextFlags();
    HRESULT FinishCommandList(
        BOOL RestoreDeferredContextState,
        [annotation("_COM_Outptr_opt_")] ID3D11CommandList** ppCommandList );
    
    // !!! END LOW-FREQUENCY !!!
};

cpp_quote( "#if !defined( D3D11_VIDEO_NO_HELPERS ) && defined( __cplusplus )" )
cpp_quote( "}" ) // extern C
cpp_quote( "struct CD3D11_VIDEO_DEFAULT {};" )
cpp_quote( "extern const DECLSPEC_SELECTANY CD3D11_VIDEO_DEFAULT D3D11_VIDEO_DEFAULT;" )
cpp_quote( "extern \"C\"{" )
cpp_quote( "#endif" )

interface ID3D11VideoDecoderOutputView;
interface ID3D11VideoProcessorInputView;

cpp_quote("#if !defined(APP_DEPRECATED_HRESULT) && !defined(APP_DEPRECATED_HRESULT_TYPEDEF)")
cpp_quote("#define APP_DEPRECATED_HRESULT_TYPEDEF")
typedef HRESULT APP_DEPRECATED_HRESULT;
cpp_quote("#endif")

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VideoDecoder
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_MOCOMP,      0xe6a9f44b, 0x61b0, 0x4563,0x9e,0xa4,0x63,0xd2,0xa3,0xc6,0xfe,0x66);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_IDCT,        0xbf22ad00, 0x03ea, 0x4690,0x80,0x77,0x47,0x33,0x46,0x20,0x9b,0x7e);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_VLD,         0xee27417f, 0x5e28, 0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG1_VLD,         0x6f3ec719, 0x3735, 0x42cc,0x80,0x63,0x65,0xcc,0x3c,0xb3,0x66,0x16);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2and1_VLD,     0x86695f12, 0x340e, 0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT, 0x1b81be64, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_MOCOMP_FGT,   0x1b81be65, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_IDCT_NOFGT,   0x1b81be66, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_IDCT_FGT,     0x1b81be67, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_NOFGT,    0x1b81be68, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_FGT,      0x1b81be69, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT,  0xd5f04ff9, 0x3418,0x45d8,0x95,0x61,0x32,0xa7,0x6a,0xae,0x2d,0xdd);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT, 0xd79be8da, 0x0cf1,0x4c81,0xb8,0x2a,0x69,0xa4,0xe2,0x36,0xf4,0x3d);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT,             0xf9aaccbb, 0xc2b6,0x4cfc,0x87,0x79,0x57,0x07,0xb1,0x76,0x05,0x52);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT,          0x705b9d82, 0x76cf,0x49d6,0xb7,0xe6,0xac,0x88,0x72,0xdb,0x01,0x3c);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV8_POSTPROC,     0x1b81be80, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV8_MOCOMP,       0x1b81be81, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_POSTPROC,     0x1b81be90, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_MOCOMP,       0x1b81be91, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_IDCT,         0x1b81be94, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_POSTPROC,      0x1b81beA0, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_MOCOMP,        0x1b81beA1, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_IDCT,          0x1b81beA2, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_VLD,           0x1b81beA3, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_D2010,         0x1b81beA4, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE,           0xefd64d74, 0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC,  0xed418a9f, 0x010d,0x4eda,0x9a,0xe3,0x9a,0x65,0x35,0x8d,0x8d,0x2e);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC,    0xab998b5b, 0x4258,0x44a9,0x9f,0xeb,0x94,0xe5,0x97,0xa6,0xba,0xae);")

cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_HEVC_VLD_MAIN,     0x5b11d51b, 0x2f4c,0x4452,0xbc,0xc3,0x09,0xf2,0xa1,0x16,0x0c,0xc0);")
cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10,   0x107af0e0, 0xef1a,0x4d19,0xab,0xa8,0x67,0xa1,0x63,0x07,0x3d,0x13);")


typedef struct D3D11_VIDEO_DECODER_DESC
{

    GUID        Guid;
    UINT        SampleWidth;
    UINT        SampleHeight;
    DXGI_FORMAT OutputFormat;
} D3D11_VIDEO_DECODER_DESC;

typedef struct D3D11_VIDEO_DECODER_CONFIG
{
    GUID guidConfigBitstreamEncryption;
    GUID guidConfigMBcontrolEncryption;
    GUID guidConfigResidDiffEncryption;
    UINT ConfigBitstreamRaw;
    UINT ConfigMBcontrolRasterOrder;
    UINT ConfigResidDiffHost;
    UINT ConfigSpatialResid8;
    UINT ConfigResid8Subtraction;
    UINT ConfigSpatialHost8or9Clipping;
    UINT ConfigSpatialResidInterleaved;
    UINT ConfigIntraResidUnsigned;
    UINT ConfigResidDiffAccelerator;
    UINT ConfigHostInverseScan;
    UINT ConfigSpecificIDCT;
    UINT Config4GroupedCoefs;
    USHORT ConfigMinRenderTargetBuffCount;
    USHORT ConfigDecoderSpecific;
} D3D11_VIDEO_DECODER_CONFIG;


typedef enum D3D11_VIDEO_DECODER_BUFFER_TYPE
{
    D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS               = 0,
    D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL               = 1,
    D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE              = 2,
    D3D11_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL               = 3,
    D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX      = 4,
    D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL                    = 5,
    D3D11_VIDEO_DECODER_BUFFER_BITSTREAM                        = 6,
    D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR                    = 7,
    D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN                       = 8
} D3D11_VIDEO_DECODER_BUFFER_TYPE;

typedef struct _D3D11_AES_CTR_IV
{
    UINT64   IV;         // Big-Endian IV
    UINT64   Count;      // Big-Endian Block Count
} D3D11_AES_CTR_IV;

typedef struct D3D11_ENCRYPTED_BLOCK_INFO
{
    UINT NumEncryptedBytesAtBeginning;    
    UINT NumBytesInSkipPattern;
    UINT NumBytesInEncryptPattern;
} D3D11_ENCRYPTED_BLOCK_INFO;

typedef struct D3D11_VIDEO_DECODER_BUFFER_DESC
{
    D3D11_VIDEO_DECODER_BUFFER_TYPE BufferType;
    UINT BufferIndex;
    UINT DataOffset;
    UINT DataSize;
    UINT FirstMBaddress;
    UINT NumMBsInBuffer;
    UINT Width;
    UINT Height;
    UINT Stride;
    UINT ReservedBits;
    [annotation("_Field_size_opt_(IVSize)")] void* pIV;
    UINT IVSize;
    BOOL PartialEncryption;
    D3D11_ENCRYPTED_BLOCK_INFO EncryptedBlockInfo;
} D3D11_VIDEO_DECODER_BUFFER_DESC;

typedef struct D3D11_VIDEO_DECODER_EXTENSION
{
    UINT Function;
    [annotation("_Field_size_(PrivateInputDataSize)")] void* pPrivateInputData;
    UINT PrivateInputDataSize;
    [annotation("_Field_size_(PrivateOutputDataSize)")] void* pPrivateOutputData;
    UINT PrivateOutputDataSize;
    UINT ResourceCount;
    [annotation("_Field_size_opt_(ResourceCount)")] ID3D11Resource** ppResourceList;
} D3D11_VIDEO_DECODER_EXTENSION;

[ uuid( 3C9C5B51-995D-48d1-9B8D-FA5CAEDED65C ), object, local, pointer_default( unique ) ]
interface ID3D11VideoDecoder
    : ID3D11DeviceChild
{
    HRESULT GetCreationParameters( 
                [annotation("_Out_")] D3D11_VIDEO_DECODER_DESC* pVideoDesc,
                [annotation("_Out_")] D3D11_VIDEO_DECODER_CONFIG *pConfig );

    HRESULT GetDriverHandle( 
                [annotation("_Out_")] HANDLE* pDriverHandle );
};


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VideoProcessorEnum
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef enum D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT
{
    D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_INPUT = 0x00000001,
    D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT_OUTPUT = 0x00000002,
} D3D11_VIDEO_PROCESSOR_FORMAT_SUPPORT;

typedef enum D3D11_VIDEO_PROCESSOR_DEVICE_CAPS
{
    D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_LINEAR_SPACE            = 0x1,
    D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_xvYCC                   = 0x2,
    D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_RGB_RANGE_CONVERSION    = 0x4,
    D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_YCbCr_MATRIX_CONVERSION = 0x8,
    D3D11_VIDEO_PROCESSOR_DEVICE_CAPS_NOMINAL_RANGE           = 0x10
} D3D11_VIDEO_PROCESSOR_DEVICE_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_FEATURE_CAPS
{
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_FILL             = 0x1,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_CONSTRICTION           = 0x2,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LUMA_KEY               = 0x4,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_PALETTE          = 0x8,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_LEGACY                 = 0x10,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_STEREO                 = 0x20,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ROTATION               = 0x40,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_ALPHA_STREAM           = 0x80,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_PIXEL_ASPECT_RATIO     = 0x100,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_MIRROR                 = 0x200,
    D3D11_VIDEO_PROCESSOR_FEATURE_CAPS_SHADER_USAGE           = 0x400,
} D3D11_VIDEO_PROCESSOR_FEATURE_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_FILTER_CAPS
{
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_BRIGHTNESS         = 0x1,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_CONTRAST           = 0x2,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_HUE                = 0x4,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_SATURATION         = 0x8,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_NOISE_REDUCTION    = 0x10,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_EDGE_ENHANCEMENT   = 0x20,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_ANAMORPHIC_SCALING = 0x40,
    D3D11_VIDEO_PROCESSOR_FILTER_CAPS_STEREO_ADJUSTMENT  = 0x80
} D3D11_VIDEO_PROCESSOR_FILTER_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_FORMAT_CAPS
{
    D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_INTERLACED     = 0x1,
    D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_PROCAMP        = 0x2,
    D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_RGB_LUMA_KEY       = 0x4,
    D3D11_VIDEO_PROCESSOR_FORMAT_CAPS_PALETTE_INTERLACED = 0x8
} D3D11_VIDEO_PROCESSOR_FORMAT_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS
{
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DENOISE              = 0x01,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_DERINGING            = 0x02,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_EDGE_ENHANCEMENT     = 0x04,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_COLOR_CORRECTION     = 0x08,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_FLESH_TONE_MAPPING   = 0x10,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_IMAGE_STABILIZATION  = 0x20,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_SUPER_RESOLUTION     = 0x40,
    D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS_ANAMORPHIC_SCALING   = 0x80
} D3D11_VIDEO_PROCESSOR_AUTO_STREAM_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_STEREO_CAPS
{
    D3D11_VIDEO_PROCESSOR_STEREO_CAPS_MONO_OFFSET         = 0x01,
    D3D11_VIDEO_PROCESSOR_STEREO_CAPS_ROW_INTERLEAVED     = 0x02,
    D3D11_VIDEO_PROCESSOR_STEREO_CAPS_COLUMN_INTERLEAVED  = 0x04,
    D3D11_VIDEO_PROCESSOR_STEREO_CAPS_CHECKERBOARD        = 0x08,
    D3D11_VIDEO_PROCESSOR_STEREO_CAPS_FLIP_MODE           = 0x10
} D3D11_VIDEO_PROCESSOR_STEREO_CAPS;

typedef struct D3D11_VIDEO_PROCESSOR_CAPS
{
    UINT DeviceCaps;
    UINT FeatureCaps;
    UINT FilterCaps;
    UINT InputFormatCaps;
    UINT AutoStreamCaps;
    UINT StereoCaps;
    UINT RateConversionCapsCount;
    UINT MaxInputStreams;
    UINT MaxStreamStates;
} D3D11_VIDEO_PROCESSOR_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS 
{
    D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND                 = 0x1,
    D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB                   = 0x2,
    D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE              = 0x4,
    D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION   = 0x8,
    D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_INVERSE_TELECINE                  = 0x10,
    D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_FRAME_RATE_CONVERSION             = 0x20 
} D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS;

typedef enum D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS 
{
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32             = 0x1,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_22             = 0x2,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2224           = 0x4,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_2332           = 0x8,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_32322          = 0x10,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_55             = 0x20,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_64             = 0x40,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_87             = 0x80,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_222222222223   = 0x100,
    D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS_OTHER          = 0x80000000 
} D3D11_VIDEO_PROCESSOR_ITELECINE_CAPS;

typedef struct D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS
{
    UINT PastFrames;
    UINT FutureFrames;
    UINT ProcessorCaps;
    UINT ITelecineCaps;
    UINT CustomRateCount;
} D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS;

typedef enum D3D11_CONTENT_PROTECTION_CAPS
{
    D3D11_CONTENT_PROTECTION_CAPS_SOFTWARE                = 0x00000001,
    D3D11_CONTENT_PROTECTION_CAPS_HARDWARE                = 0x00000002,
    D3D11_CONTENT_PROTECTION_CAPS_PROTECTION_ALWAYS_ON    = 0x00000004,
    D3D11_CONTENT_PROTECTION_CAPS_PARTIAL_DECRYPTION      = 0x00000008,
    D3D11_CONTENT_PROTECTION_CAPS_CONTENT_KEY             = 0x00000010,
    D3D11_CONTENT_PROTECTION_CAPS_FRESHEN_SESSION_KEY     = 0x00000020,
    D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK     = 0x00000040,
    D3D11_CONTENT_PROTECTION_CAPS_ENCRYPTED_READ_BACK_KEY = 0x00000080,
    D3D11_CONTENT_PROTECTION_CAPS_SEQUENTIAL_CTR_IV       = 0x00000100,
    D3D11_CONTENT_PROTECTION_CAPS_ENCRYPT_SLICEDATA_ONLY  = 0x00000200,
    D3D11_CONTENT_PROTECTION_CAPS_DECRYPTION_BLT          = 0x00000400,
    D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_PROTECT_UNCOMPRESSED = 0x00000800,
    D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_PROTECTED_MEMORY_PAGEABLE = 0x00001000,
    D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_TEARDOWN          = 0x00002000,
    D3D11_CONTENT_PROTECTION_CAPS_HARDWARE_DRM_COMMUNICATION = 0x00004000
} D3D11_CONTENT_PROTECTION_CAPS;

cpp_quote("DEFINE_GUID(D3D11_CRYPTO_TYPE_AES128_CTR, 0x9b6bd711, 0x4f74, 0x41c9, 0x9e, 0x7b, 0xb, 0xe2, 0xd7, 0xd9, 0x3b, 0x4f );")

cpp_quote("DEFINE_GUID(D3D11_DECODER_ENCRYPTION_HW_CENC, 0x89d6ac4f, 0x9f2, 0x4229, 0xb2, 0xcd, 0x37, 0x74, 0xa, 0x6d, 0xfd, 0x81);")

cpp_quote("DEFINE_GUID(D3D11_KEY_EXCHANGE_HW_PROTECTION, 0xb1170d8a, 0x628d, 0x4da3, 0xad, 0x3b, 0x82, 0xdd, 0xb0, 0x8b, 0x49, 0x70);")

typedef struct D3D11_VIDEO_CONTENT_PROTECTION_CAPS
{
    UINT      Caps;
    UINT      KeyExchangeTypeCount;
    UINT      BlockAlignmentSize;
    ULONGLONG ProtectedMemorySize;
} D3D11_VIDEO_CONTENT_PROTECTION_CAPS;

typedef struct D3D11_VIDEO_PROCESSOR_CUSTOM_RATE 
{
    DXGI_RATIONAL CustomRate;
    UINT          OutputFrames;
    BOOL          InputInterlaced;
    UINT          InputFramesOrFields;
} D3D11_VIDEO_PROCESSOR_CUSTOM_RATE;

typedef enum D3D11_VIDEO_PROCESSOR_FILTER 
{
    D3D11_VIDEO_PROCESSOR_FILTER_BRIGHTNESS           = 0,
    D3D11_VIDEO_PROCESSOR_FILTER_CONTRAST             = 1,
    D3D11_VIDEO_PROCESSOR_FILTER_HUE                  = 2,
    D3D11_VIDEO_PROCESSOR_FILTER_SATURATION           = 3,
    D3D11_VIDEO_PROCESSOR_FILTER_NOISE_REDUCTION      = 4,
    D3D11_VIDEO_PROCESSOR_FILTER_EDGE_ENHANCEMENT     = 5,
    D3D11_VIDEO_PROCESSOR_FILTER_ANAMORPHIC_SCALING   = 6, 
    D3D11_VIDEO_PROCESSOR_FILTER_STEREO_ADJUSTMENT    = 7,
} D3D11_VIDEO_PROCESSOR_FILTER;

typedef struct D3D11_VIDEO_PROCESSOR_FILTER_RANGE 
{
  int   Minimum;
  int   Maximum;
  int   Default;
  float Multiplier;
} D3D11_VIDEO_PROCESSOR_FILTER_RANGE;

typedef enum D3D11_VIDEO_FRAME_FORMAT
{
    D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE	= 0,
    D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST	= 1,
    D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST	= 2
} D3D11_VIDEO_FRAME_FORMAT;

typedef enum D3D11_VIDEO_USAGE
{
    D3D11_VIDEO_USAGE_PLAYBACK_NORMAL = 0,
    D3D11_VIDEO_USAGE_OPTIMAL_SPEED	  = 1,
    D3D11_VIDEO_USAGE_OPTIMAL_QUALITY = 2
} D3D11_VIDEO_USAGE;

typedef struct D3D11_VIDEO_PROCESSOR_CONTENT_DESC
{
    D3D11_VIDEO_FRAME_FORMAT InputFrameFormat;
    DXGI_RATIONAL InputFrameRate;
    UINT InputWidth;
    UINT InputHeight;
    DXGI_RATIONAL OutputFrameRate;
    UINT OutputWidth;
    UINT OutputHeight;
    D3D11_VIDEO_USAGE Usage;
} D3D11_VIDEO_PROCESSOR_CONTENT_DESC;


[ uuid( 31627037-53AB-4200-9061-05FAA9AB45F9 ), object, local, pointer_default( unique ) ]
interface ID3D11VideoProcessorEnumerator : ID3D11DeviceChild
{
    HRESULT GetVideoProcessorContentDesc(
        [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pContentDesc );

    HRESULT CheckVideoProcessorFormat(
        [annotation("_In_")] DXGI_FORMAT Format,
        [annotation("_Out_")] UINT* pFlags );

    HRESULT GetVideoProcessorCaps(
        [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_CAPS* pCaps );

    HRESULT GetVideoProcessorRateConversionCaps(
        [annotation("_In_")] UINT TypeIndex,
        [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps );

    HRESULT GetVideoProcessorCustomRate(
        [annotation("_In_")] UINT TypeIndex,
        [annotation("_In_")] UINT CustomRateIndex,
        [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_CUSTOM_RATE* pRate );

    HRESULT GetVideoProcessorFilterRange(
        [annotation("_In_")] D3D11_VIDEO_PROCESSOR_FILTER Filter,
        [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_FILTER_RANGE* pRange );
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VideoProcessor
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef struct D3D11_VIDEO_COLOR_RGBA 
{
    float R;
    float G;
    float B;
    float A;
} D3D11_VIDEO_COLOR_RGBA;

typedef struct D3D11_VIDEO_COLOR_YCbCrA 
{
    float Y;
    float Cb;
    float Cr;
    float A;
} D3D11_VIDEO_COLOR_YCbCrA;

typedef struct D3D11_VIDEO_COLOR 
{
    union
    {
        D3D11_VIDEO_COLOR_YCbCrA YCbCr;
        D3D11_VIDEO_COLOR_RGBA RGBA;
    };
} D3D11_VIDEO_COLOR;

typedef enum D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE 
{
    D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_UNDEFINED         = 0,
    D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_16_235            = 1,
    D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255             = 2
} D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE;

typedef struct D3D11_VIDEO_PROCESSOR_COLOR_SPACE 
{
    UINT Usage  :1;
    UINT RGB_Range  :1;
    UINT YCbCr_Matrix  :1;
    UINT YCbCr_xvYCC  :1;
    UINT Nominal_Range :2;   // D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE
    UINT Reserved : 26;
} D3D11_VIDEO_PROCESSOR_COLOR_SPACE;

typedef enum D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE 
{
    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE          = 0,
    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_BACKGROUND      = 1,
    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_DESTINATION     = 2,
    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM   = 3 
} D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE;

typedef enum D3D11_VIDEO_PROCESSOR_OUTPUT_RATE 
{
    D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL   = 0,
    D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_HALF     = 1,
    D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM   = 2 
} D3D11_VIDEO_PROCESSOR_OUTPUT_RATE;

typedef enum D3D11_VIDEO_PROCESSOR_STEREO_FORMAT
{
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO               = 0,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_HORIZONTAL         = 1,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_VERTICAL           = 2,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE           = 3,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET        = 4,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_ROW_INTERLEAVED    = 5,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_COLUMN_INTERLEAVED = 6,
    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_CHECKERBOARD       = 7
} D3D11_VIDEO_PROCESSOR_STEREO_FORMAT;

typedef enum D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE
{
    D3D11_VIDEO_PROCESSOR_STEREO_FLIP_NONE   = 0,
    D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME0 = 1,
    D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME1 = 2,
} D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE;

typedef enum D3D11_VIDEO_PROCESSOR_ROTATION 
{
    D3D11_VIDEO_PROCESSOR_ROTATION_IDENTITY      = 0,
    D3D11_VIDEO_PROCESSOR_ROTATION_90            = 1,
    D3D11_VIDEO_PROCESSOR_ROTATION_180           = 2,
    D3D11_VIDEO_PROCESSOR_ROTATION_270           = 3,
} D3D11_VIDEO_PROCESSOR_ROTATION;

typedef struct D3D11_VIDEO_PROCESSOR_STREAM
{
    BOOL Enable;
    UINT OutputIndex;
    UINT InputFrameOrField;
    UINT PastFrames;
    UINT FutureFrames;
    [annotation("_Field_size_(PastFrames)")] ID3D11VideoProcessorInputView **ppPastSurfaces;
    ID3D11VideoProcessorInputView *pInputSurface;
    [annotation("_Field_size_(FutureFrames)")] ID3D11VideoProcessorInputView **ppFutureSurfaces;
    [annotation("_Field_size_opt_(PastFrames)")] ID3D11VideoProcessorInputView **ppPastSurfacesRight;
    ID3D11VideoProcessorInputView *pInputSurfaceRight;
    [annotation("_Field_size_(FutureFrames)")] ID3D11VideoProcessorInputView **ppFutureSurfacesRight;
} D3D11_VIDEO_PROCESSOR_STREAM;


[ uuid( 1D7B0652-185F-41c6-85CE-0C5BE3D4AE6C ), object, local, pointer_default( unique ) ]
interface ID3D11VideoProcessor
    : ID3D11DeviceChild
{
    void GetContentDesc( 
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pDesc);

    void GetRateConversionCaps(
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS* pCaps);
};


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// AuthenticatedChannel
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define D3D11_OMAC_SIZE    16

typedef struct D3D11_OMAC
{
    BYTE Omac[D3D11_OMAC_SIZE];
} D3D11_OMAC;

typedef enum D3D11_AUTHENTICATED_CHANNEL_TYPE
{
    D3D11_AUTHENTICATED_CHANNEL_D3D11           = 1,
    D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE = 2,
    D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE = 3,
} D3D11_AUTHENTICATED_CHANNEL_TYPE;


[ uuid( 3015A308-DCBD-47aa-A747-192486D14D4A ), object, local, pointer_default( unique ) ]
interface ID3D11AuthenticatedChannel
    : ID3D11DeviceChild
{
    HRESULT GetCertificateSize( 
                [annotation("_Out_")] UINT* pCertificateSize);

    HRESULT GetCertificate(
                [annotation("_In_")] UINT CertificateSize, 
                [annotation("_Out_writes_bytes_(CertificateSize)")] BYTE* pCertificate);

    void GetChannelHandle(
                [annotation("_Out_")] HANDLE* pChannelHandle); 
};

cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_PROTECTION, 0xa84eb584, 0xc495, 0x48aa, 0xb9, 0x4d, 0x8b, 0xd2, 0xd6, 0xfb, 0xce, 0x5 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE, 0xbc1b18a5, 0xb1fb, 0x42ab, 0xbd, 0x94, 0xb5, 0x82, 0x8b, 0x4b, 0xf7, 0xbe );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE, 0xec1c539d, 0x8cff, 0x4e2a, 0xbc, 0xc4, 0xf5, 0x69, 0x2f, 0x99, 0xf4, 0x80 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION, 0x2634499e, 0xd018, 0x4d74, 0xac, 0x17, 0x7f, 0x72, 0x40, 0x59, 0x52, 0x8d );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT, 0xdb207b3, 0x9450, 0x46a6, 0x82, 0xde, 0x1b, 0x96, 0xd4, 0x4f, 0x9c, 0xf2 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS, 0x649bbadb, 0xf0f4, 0x4639, 0xa1, 0x5b, 0x24, 0x39, 0x3f, 0xc3, 0xab, 0xac );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT, 0x12f0bd6, 0xe662, 0x4474, 0xbe, 0xfd, 0xaa, 0x53, 0xe5, 0x14, 0x3c, 0x6d );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT, 0x2c042b5e, 0x8c07, 0x46d5, 0xaa, 0xbe, 0x8f, 0x75, 0xcb, 0xad, 0x4c, 0x31 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_OUTPUT_ID, 0x839ddca3, 0x9b4e, 0x41e4, 0xb0, 0x53, 0x89, 0x2b, 0xd2, 0xa1, 0x1e, 0xe7 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ATTRIBUTES, 0x6214d9d2, 0x432c, 0x4abb, 0x9f, 0xce, 0x21, 0x6e, 0xea, 0x26, 0x9e, 0x3b );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID_COUNT, 0xb30f7066, 0x203c, 0x4b07, 0x93, 0xfc, 0xce, 0xaa, 0xfd, 0x61, 0x24, 0x1e );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_ENCRYPTION_WHEN_ACCESSIBLE_GUID, 0xf83a5958, 0xe986, 0x4bda, 0xbe, 0xb0, 0x41, 0x1f, 0x6a, 0x7a, 0x1, 0xb7 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_QUERY_CURRENT_ENCRYPTION_WHEN_ACCESSIBLE, 0xec1791c7, 0xdad3, 0x4f15, 0x9e, 0xc3, 0xfa, 0xa9, 0x3d, 0x60, 0xd4, 0xf0 );")

cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE, 0x6114bdb, 0x3523, 0x470a, 0x8d, 0xca, 0xfb, 0xc2, 0x84, 0x51, 0x54, 0xf0 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_CONFIGURE_PROTECTION, 0x50455658, 0x3f47, 0x4362, 0xbf, 0x99, 0xbf, 0xdf, 0xcd, 0xe9, 0xed, 0x29 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION, 0x6346cc54, 0x2cfc, 0x4ad4, 0x82, 0x24, 0xd1, 0x58, 0x37, 0xde, 0x77, 0x0 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE, 0x772d047, 0x1b40, 0x48e8, 0x9c, 0xa6, 0xb5, 0xf5, 0x10, 0xde, 0x9f, 0x1 );")
cpp_quote("DEFINE_GUID( D3D11_AUTHENTICATED_CONFIGURE_ENCRYPTION_WHEN_ACCESSIBLE, 0x41fff286, 0x6ae0, 0x4d43, 0x9d, 0x55, 0xa4, 0x6e, 0x9e, 0xfd, 0x15, 0x8a );")

typedef struct D3D11_AUTHENTICATED_QUERY_INPUT
{
    GUID                               QueryType;
    HANDLE                             hChannel;
    UINT                               SequenceNumber;
} D3D11_AUTHENTICATED_QUERY_INPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT
{
    D3D11_OMAC                         omac;  
    GUID                               QueryType;
    HANDLE                             hChannel;
    UINT                               SequenceNumber;
    HRESULT                            ReturnCode;
} D3D11_AUTHENTICATED_QUERY_OUTPUT;

typedef union D3D11_AUTHENTICATED_PROTECTION_FLAGS
{
    struct
    {
        UINT ProtectionEnabled                       : 1; 
        UINT OverlayOrFullscreenRequired             : 1;
        UINT Reserved                                : 30;
    } Flags;
    UINT  Value;
} D3D11_AUTHENTICATED_PROTECTION_FLAGS;

typedef struct D3D11_AUTHENTICATED_QUERY_PROTECTION_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    D3D11_AUTHENTICATED_PROTECTION_FLAGS ProtectionFlags;

} D3D11_AUTHENTICATED_QUERY_PROTECTION_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType;

} D3D11_AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    HANDLE   DeviceHandle;
} D3D11_AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT
{
    D3D11_AUTHENTICATED_QUERY_INPUT Input;
    HANDLE   DecoderHandle;
} D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    HANDLE   DecoderHandle;
    HANDLE   CryptoSessionHandle;
    HANDLE   DeviceHandle;
} D3D11_AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    UINT   RestrictedSharedResourceProcessCount;
} D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT
{
    D3D11_AUTHENTICATED_QUERY_INPUT Input;
    UINT     ProcessIndex;
} D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT;

typedef enum D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE
{
    D3D11_PROCESSIDTYPE_UNKNOWN  = 0,
    D3D11_PROCESSIDTYPE_DWM      = 1,
    D3D11_PROCESSIDTYPE_HANDLE   = 2
} D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE;

typedef struct D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    UINT                                        ProcessIndex;
    D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE ProcessIdentifier;
    HANDLE                                      ProcessHandle;
} D3D11_AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    UINT  UnrestrictedProtectedSharedResourceCount;
} D3D11_AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT
{
    D3D11_AUTHENTICATED_QUERY_INPUT Input;
    HANDLE  DeviceHandle;
    HANDLE  CryptoSessionHandle;	
} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    HANDLE  DeviceHandle;
    HANDLE  CryptoSessionHandle;	
    UINT    OutputIDCount;
} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_INPUT
{
    D3D11_AUTHENTICATED_QUERY_INPUT Input;
    HANDLE  DeviceHandle;
    HANDLE  CryptoSessionHandle;	
    UINT    OutputIDIndex;
} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_INPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    HANDLE  DeviceHandle;
    HANDLE  CryptoSessionHandle;	
    UINT    OutputIDIndex;
    UINT64  OutputID;
} D3D11_AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT;

typedef enum D3D11_BUS_TYPE
{
    D3D11_BUS_TYPE_OTHER                                     = 0x00000000,
    D3D11_BUS_TYPE_PCI                                       = 0x00000001,
    D3D11_BUS_TYPE_PCIX                                      = 0x00000002,
    D3D11_BUS_TYPE_PCIEXPRESS                                = 0x00000003,
    D3D11_BUS_TYPE_AGP                                       = 0x00000004,
    D3D11_BUS_IMPL_MODIFIER_INSIDE_OF_CHIPSET                = 0x00010000,
    D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_CHIP   = 0x00020000,
    D3D11_BUS_IMPL_MODIFIER_TRACKS_ON_MOTHER_BOARD_TO_SOCKET = 0x00030000,
    D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR         = 0x00040000,
    D3D11_BUS_IMPL_MODIFIER_DAUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE = 0x00050000, 
    D3D11_BUS_IMPL_MODIFIER_NON_STANDARD                     = 0x80000000,    
} D3D11_BUS_TYPE;

typedef struct D3D11_AUTHENTICATED_QUERY_ACESSIBILITY_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    D3D11_BUS_TYPE BusType;
    BOOL AccessibleInContiguousBlocks;
    BOOL AccessibleInNonContiguousBlocks;
} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    UINT   EncryptionGuidCount;
} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT
{
    D3D11_AUTHENTICATED_QUERY_INPUT Input;
    UINT EncryptionGuidIndex;
} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    UINT       EncryptionGuidIndex;
    GUID       EncryptionGuid;
} D3D11_AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT;

typedef struct D3D11_AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT
{
    D3D11_AUTHENTICATED_QUERY_OUTPUT Output;
    GUID       EncryptionGuid;
} D3D11_AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_INPUT
{
    D3D11_OMAC                          omac;  
    GUID                                ConfigureType;      
    HANDLE                              hChannel;    
    UINT                                SequenceNumber;     
} D3D11_AUTHENTICATED_CONFIGURE_INPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_OUTPUT
{
    D3D11_OMAC                          omac;  
    GUID                                ConfigureType;          
    HANDLE                              hChannel;
    UINT                                SequenceNumber;     
    HRESULT                             ReturnCode;
} D3D11_AUTHENTICATED_CONFIGURE_OUTPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT
{
    D3D11_AUTHENTICATED_CONFIGURE_INPUT   Parameters;
    UINT   StartSequenceQuery;
    UINT   StartSequenceConfigure;
} D3D11_AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_PROTECTION_INPUT
{
    D3D11_AUTHENTICATED_CONFIGURE_INPUT   Parameters;
    D3D11_AUTHENTICATED_PROTECTION_FLAGS Protections;
} D3D11_AUTHENTICATED_CONFIGURE_PROTECTION_INPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT
{
    D3D11_AUTHENTICATED_CONFIGURE_INPUT   Parameters;
    HANDLE      DecoderHandle;
    HANDLE      CryptoSessionHandle;
    HANDLE      DeviceHandle;
} D3D11_AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT
{
    D3D11_AUTHENTICATED_CONFIGURE_INPUT         Parameters;
    D3D11_AUTHENTICATED_PROCESS_IDENTIFIER_TYPE ProcessType;
    HANDLE                                      ProcessHandle;
    BOOL                                        AllowAccess;
} D3D11_AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT;

typedef struct D3D11_AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT
{
    D3D11_AUTHENTICATED_CONFIGURE_INPUT Parameters;
    GUID                                EncryptionGuid;
} D3D11_AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CryptoSession
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


cpp_quote("DEFINE_GUID(D3D11_KEY_EXCHANGE_RSAES_OAEP, 0xc1949895, 0xd72a, 0x4a1d, 0x8e, 0x5d, 0xed, 0x85, 0x7d, 0x17, 0x15, 0x20);")

[ uuid( 9B32F9AD-BDCC-40a6-A39D-D5C865845720 ), object, local, pointer_default( unique ) ]
interface ID3D11CryptoSession
    : ID3D11DeviceChild
{
    void GetCryptoType(
                [annotation("_Out_")] GUID* pCryptoType);
                
    void GetDecoderProfile(
                [annotation("_Out_")] GUID* pDecoderProfile);

    HRESULT GetCertificateSize( 
                [annotation("_Out_")] UINT* pCertificateSize);

    HRESULT GetCertificate(
                [annotation("_In_")] UINT CertificateSize, 
                [annotation("_Out_writes_bytes_(CertificateSize)")] BYTE* pCertificate);

    void GetCryptoSessionHandle(
                [annotation("_Out_")] HANDLE* pCryptoSessionHandle);
};

typedef enum D3D11_VDOV_DIMENSION
{
    D3D11_VDOV_DIMENSION_UNKNOWN = 0,
    D3D11_VDOV_DIMENSION_TEXTURE2D = 1,
} D3D11_VDOV_DIMENSION;

typedef struct D3D11_TEX2D_VDOV
{
    UINT ArraySlice;
} D3D11_TEX2D_VDOV;

typedef struct D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC
{
    GUID DecodeProfile;
    D3D11_VDOV_DIMENSION ViewDimension;

    union
    {
        D3D11_TEX2D_VDOV Texture2D;
    };
} D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC;

[ uuid( C2931AEA-2A85-4f20-860F-FBA1FD256E18 ), object, local, pointer_default( unique ) ]
interface ID3D11VideoDecoderOutputView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc );
};

typedef enum D3D11_VPIV_DIMENSION
{
    D3D11_VPIV_DIMENSION_UNKNOWN = 0,
    D3D11_VPIV_DIMENSION_TEXTURE2D = 1,
} D3D11_VPIV_DIMENSION;

typedef struct D3D11_TEX2D_VPIV
{
    UINT MipSlice;
    UINT ArraySlice;
} D3D11_TEX2D_VPIV;

typedef struct D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC
{
    UINT FourCC;
    D3D11_VPIV_DIMENSION ViewDimension;

    union
    {
        D3D11_TEX2D_VPIV Texture2D;
    };
} D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC;

[ uuid( 11EC5A5F-51DC-4945-AB34-6E8C21300EA5 ), object, local, pointer_default( unique ) ]
interface ID3D11VideoProcessorInputView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc );
};

typedef enum D3D11_VPOV_DIMENSION
{
    D3D11_VPOV_DIMENSION_UNKNOWN = 0,
    D3D11_VPOV_DIMENSION_TEXTURE2D = 1,
    D3D11_VPOV_DIMENSION_TEXTURE2DARRAY = 2,
} D3D11_VPOV_DIMENSION;

typedef struct D3D11_TEX2D_VPOV
{
    UINT MipSlice;
} D3D11_TEX2D_VPOV;

typedef struct D3D11_TEX2D_ARRAY_VPOV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} D3D11_TEX2D_ARRAY_VPOV;

typedef struct D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC
{
    D3D11_VPOV_DIMENSION ViewDimension;

    union
    {
        D3D11_TEX2D_VPOV Texture2D;
        D3D11_TEX2D_ARRAY_VPOV Texture2DArray;
    };
} D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC;

[ uuid( A048285E-25A9-4527-BD93-D68B68C44254 ), object, local, pointer_default( unique ) ]
interface ID3D11VideoProcessorOutputView
    : ID3D11View
{
    void GetDesc( [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC* pDesc );
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// VideoContext
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[ uuid( 61F21C45-3C0E-4a74-9CEA-67100D9AD5E4 ), object, local, pointer_default( unique ) ]
interface ID3D11VideoContext
    : ID3D11DeviceChild
{
    // Decode
    HRESULT GetDecoderBuffer( 
                [annotation("_In_")] ID3D11VideoDecoder* pDecoder,
                D3D11_VIDEO_DECODER_BUFFER_TYPE Type, 
                [annotation("_Out_")] UINT* pBufferSize,
                [annotation("_Outptr_result_bytebuffer_(*pBufferSize)")] void** ppBuffer );

    HRESULT ReleaseDecoderBuffer( 
                [annotation("_In_")] ID3D11VideoDecoder* pDecoder,
                [annotation("_In_")] D3D11_VIDEO_DECODER_BUFFER_TYPE Type );

    HRESULT DecoderBeginFrame(
                [annotation("_In_")] ID3D11VideoDecoder* pDecoder,
                [annotation("_In_")] ID3D11VideoDecoderOutputView* pView,
                UINT ContentKeySize,
                [annotation("_In_reads_bytes_opt_(ContentKeySize)")] const void* pContentKey );

    HRESULT DecoderEndFrame( 
                [annotation("_In_")] ID3D11VideoDecoder* pDecoder );

    HRESULT SubmitDecoderBuffers( 
                [annotation("_In_")] ID3D11VideoDecoder* pDecoder,
                [annotation("_In_")] UINT NumBuffers, 
                [annotation("_In_reads_(NumBuffers)")] const D3D11_VIDEO_DECODER_BUFFER_DESC* pBufferDesc );

    APP_DEPRECATED_HRESULT DecoderExtension( 
                [annotation("_In_")] ID3D11VideoDecoder* pDecoder,
                [annotation("_In_")] const D3D11_VIDEO_DECODER_EXTENSION* pExtensionData );

    void VideoProcessorSetOutputTargetRect( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_opt_")] const RECT* pRect);

    void VideoProcessorSetOutputBackgroundColor( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] BOOL YCbCr,
                [annotation("_In_")] const D3D11_VIDEO_COLOR* pColor);

    void VideoProcessorSetOutputColorSpace( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace);

    void VideoProcessorSetOutputAlphaFillMode( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE AlphaFillMode,
                [annotation("_In_")] UINT StreamIndex);

    void VideoProcessorSetOutputConstriction( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_")] SIZE Size);

    void VideoProcessorSetOutputStereoMode( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] BOOL Enable);

    APP_DEPRECATED_HRESULT VideoProcessorSetOutputExtension( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] const GUID* pExtensionGuid,
                [annotation("_In_")] UINT DataSize,
                [annotation("_In_")] void* pData);

    void VideoProcessorGetOutputTargetRect( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_Out_")] BOOL* Enabled,
                [annotation("_Out_")] RECT* pRect);

    void VideoProcessorGetOutputBackgroundColor( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_Out_")] BOOL* pYCbCr,
                [annotation("_Out_")] D3D11_VIDEO_COLOR* pColor);

    void VideoProcessorGetOutputColorSpace( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace);

    void VideoProcessorGetOutputAlphaFillMode( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE* pAlphaFillMode,
                [annotation("_Out_")] UINT* pStreamIndex);

    void VideoProcessorGetOutputConstriction( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] SIZE* pSize);

    void VideoProcessorGetOutputStereoMode( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_Out_")] BOOL* pEnabled);

    APP_DEPRECATED_HRESULT VideoProcessorGetOutputExtension( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] const GUID* pExtensionGuid,
                [annotation("_In_")] UINT DataSize,
                [annotation("_Out_writes_bytes_(DataSize)")] void* pData);

    void VideoProcessorSetStreamFrameFormat( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] D3D11_VIDEO_FRAME_FORMAT FrameFormat);

    void VideoProcessorSetStreamColorSpace( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace);

    void VideoProcessorSetStreamOutputRate( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE OutputRate,
                [annotation("_In_")] BOOL RepeatFrame,
                [annotation("_In_opt_")] const DXGI_RATIONAL* pCustomRate);

    void VideoProcessorSetStreamSourceRect( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_opt_")] const RECT* pRect);

    void VideoProcessorSetStreamDestRect( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_opt_")] const RECT* pRect);

    void VideoProcessorSetStreamAlpha( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_")] FLOAT Alpha);

    void VideoProcessorSetStreamPalette( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] UINT Count,
                [annotation("_In_reads_opt_(Count)")] const UINT* pEntries);

    void VideoProcessorSetStreamPixelAspectRatio( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_opt_")] const DXGI_RATIONAL* pSourceAspectRatio,
                [annotation("_In_opt_")] const DXGI_RATIONAL* pDestinationAspectRatio);

    void VideoProcessorSetStreamLumaKey(
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_")] FLOAT Lower,
                [annotation("_In_")] FLOAT Upper);

    void VideoProcessorSetStreamStereoFormat(
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT Format,
                [annotation("_In_")] BOOL LeftViewFrame0,
                [annotation("_In_")] BOOL BaseViewFrame0,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE FlipMode,
                [annotation("_In_")] int MonoOffset);

    void VideoProcessorSetStreamAutoProcessingMode( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable);

    void VideoProcessorSetStreamFilter( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_FILTER Filter,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_")] int Level);

    APP_DEPRECATED_HRESULT VideoProcessorSetStreamExtension( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] const GUID* pExtensionGuid,
                [annotation("_In_")] UINT DataSize,
                [annotation("_In_")] void* pData);

    void VideoProcessorGetStreamFrameFormat( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] D3D11_VIDEO_FRAME_FORMAT* pFrameFormat);

    void VideoProcessorGetStreamColorSpace( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_COLOR_SPACE* pColorSpace);

    void VideoProcessorGetStreamOutputRate( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE* pOutputRate,
                [annotation("_Out_")] BOOL* pRepeatFrame,
                [annotation("_Out_")] DXGI_RATIONAL* pCustomRate);

    void VideoProcessorGetStreamSourceRect( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] RECT* pRect);

    void VideoProcessorGetStreamDestRect( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] RECT* pRect);

    void VideoProcessorGetStreamAlpha( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] FLOAT* pAlpha);

    void VideoProcessorGetStreamPalette( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] UINT Count,
                [annotation("_Out_writes_(Count)")] UINT* pEntries);

    void VideoProcessorGetStreamPixelAspectRatio( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] DXGI_RATIONAL* pSourceAspectRatio,
                [annotation("_Out_")] DXGI_RATIONAL* pDestinationAspectRatio);

    void VideoProcessorGetStreamLumaKey(
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] FLOAT* pLower,
                [annotation("_Out_")] FLOAT* pUpper);

    void VideoProcessorGetStreamStereoFormat(
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnable,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT* pFormat,
                [annotation("_Out_")] BOOL* pLeftViewFrame0,
                [annotation("_Out_")] BOOL* pBaseViewFrame0,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE* pFlipMode,
                [annotation("_Out_")] int* MonoOffset);

    void VideoProcessorGetStreamAutoProcessingMode( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnabled);

    void VideoProcessorGetStreamFilter( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_FILTER Filter,
                [annotation("_Out_")] BOOL* pEnabled,
                [annotation("_Out_")] int* pLevel);

    APP_DEPRECATED_HRESULT VideoProcessorGetStreamExtension( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] const GUID* pExtensionGuid,
                [annotation("_In_")] UINT DataSize,
                [annotation("_Out_writes_bytes_(DataSize)")] void* pData);

    HRESULT VideoProcessorBlt(
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] ID3D11VideoProcessorOutputView *pView,
                [annotation("_In_")] UINT OutputFrame,
                [annotation("_In_")] UINT StreamCount,
                [annotation("_In_reads_(StreamCount)")] const D3D11_VIDEO_PROCESSOR_STREAM *pStreams);

    HRESULT NegotiateCryptoSessionKeyExchange(
                [annotation("_In_")] ID3D11CryptoSession* pCryptoSession, 
                [annotation("_In_")] UINT DataSize, 
                [annotation("_Inout_updates_bytes_(DataSize)")] void* pData);

    void EncryptionBlt( 
                [annotation("_In_")] ID3D11CryptoSession* pCryptoSession, 
                [annotation("_In_")] ID3D11Texture2D* pSrcSurface,
                [annotation("_In_")] ID3D11Texture2D* pDstSurface,
                [annotation("_In_")] UINT IVSize,
                [annotation("_Inout_opt_bytecount_(IVSize)")] void* pIV);

    void DecryptionBlt( 
                [annotation("_In_")] ID3D11CryptoSession* pCryptoSession, 
                [annotation("_In_")] ID3D11Texture2D* pSrcSurface,
                [annotation("_In_")] ID3D11Texture2D* pDstSurface,
                [annotation("_In_opt_")] D3D11_ENCRYPTED_BLOCK_INFO* pEncryptedBlockInfo,
                [annotation("_In_")] UINT ContentKeySize,
                [annotation("_In_reads_bytes_opt_(ContentKeySize)")] const void* pContentKey,
                [annotation("_In_")] UINT IVSize,
                [annotation("_Inout_opt_bytecount_(IVSize)")] void* pIV );

    void StartSessionKeyRefresh( 
                [annotation("_In_")] ID3D11CryptoSession* pCryptoSession, 
                [annotation("_In_")] UINT RandomNumberSize, 
                [annotation("_Out_writes_bytes_(RandomNumberSize)")] void* pRandomNumber);

    void FinishSessionKeyRefresh(
                [annotation("_In_")] ID3D11CryptoSession* pCryptoSession);

    HRESULT GetEncryptionBltKey( 
                [annotation("_In_")] ID3D11CryptoSession* pCryptoSession, 
                [annotation("_In_")] UINT KeySize, 
                [annotation("_Out_writes_bytes_(KeySize)")] void* pReadbackKey);
                
    HRESULT NegotiateAuthenticatedChannelKeyExchange(
                [annotation("_In_")] ID3D11AuthenticatedChannel* pChannel, 
                [annotation("_In_")] UINT DataSize, 
                [annotation("_Inout_updates_bytes_(DataSize)")] void* pData);

    HRESULT QueryAuthenticatedChannel(
                [annotation("_In_")] ID3D11AuthenticatedChannel* pChannel, 
                [annotation("_In_")] UINT InputSize, 
                [annotation("_In_reads_bytes_(InputSize)")] const void* pInput,
                [annotation("_In_")] UINT OutputSize,
                [annotation("_Out_writes_bytes_(OutputSize)")] void* pOutput);

    HRESULT ConfigureAuthenticatedChannel( 
                [annotation("_In_")] ID3D11AuthenticatedChannel* pChannel, 
                [annotation("_In_")] UINT InputSize,
                [annotation("_In_reads_bytes_(InputSize)")] const void* pInput,
                [annotation("_Out_")] D3D11_AUTHENTICATED_CONFIGURE_OUTPUT* pOutput);

    void VideoProcessorSetStreamRotation( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_In_")] BOOL Enable,
                [annotation("_In_")] D3D11_VIDEO_PROCESSOR_ROTATION Rotation);

    void VideoProcessorGetStreamRotation( 
                [annotation("_In_")] ID3D11VideoProcessor* pVideoProcessor,
                [annotation("_In_")] UINT StreamIndex,
                [annotation("_Out_")] BOOL* pEnable,
                [annotation("_Out_")] D3D11_VIDEO_PROCESSOR_ROTATION* pRotation);
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Device
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[ uuid( 10EC4D5B-975A-4689-B9E4-D0AAC30FE333 ), object, local, pointer_default( unique ) ]
interface ID3D11VideoDevice
    : IUnknown
{
    // Create*
    HRESULT CreateVideoDecoder( 
        [annotation("_In_")] const D3D11_VIDEO_DECODER_DESC *pVideoDesc,
        [annotation("_In_")] const D3D11_VIDEO_DECODER_CONFIG *pConfig,
        [annotation("_COM_Outptr_")] ID3D11VideoDecoder **ppDecoder);

    HRESULT CreateVideoProcessor( 
        [annotation("_In_")] ID3D11VideoProcessorEnumerator* pEnum,
        [annotation("_In_")] UINT RateConversionIndex,
        [annotation("_COM_Outptr_")] ID3D11VideoProcessor **ppVideoProcessor);

    HRESULT CreateAuthenticatedChannel( 
        [annotation("_In_")] D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
        [annotation("_COM_Outptr_")] ID3D11AuthenticatedChannel** ppAuthenticatedChannel);

    HRESULT CreateCryptoSession( 
        [annotation("_In_")] const GUID* pCryptoType,
        [annotation("_In_opt_")] const GUID* pDecoderProfile,
        [annotation("_In_")] const GUID* pKeyExchangeType,
        [annotation("_COM_Outptr_")] ID3D11CryptoSession** ppCryptoSession);

    HRESULT CreateVideoDecoderOutputView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_")] const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11VideoDecoderOutputView** ppVDOVView );

    HRESULT CreateVideoProcessorInputView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_")] ID3D11VideoProcessorEnumerator* pEnum,
        [annotation("_In_")] const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11VideoProcessorInputView** ppVPIView );

    HRESULT CreateVideoProcessorOutputView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_")] ID3D11VideoProcessorEnumerator* pEnum,
        [annotation("_In_")] const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11VideoProcessorOutputView** ppVPOView );

    HRESULT CreateVideoProcessorEnumerator(
        [annotation("_In_")] const D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pDesc,
        [annotation("_COM_Outptr_")] ID3D11VideoProcessorEnumerator** ppEnum );

    // Check
    UINT GetVideoDecoderProfileCount( void );

    HRESULT GetVideoDecoderProfile(
        [annotation("_In_")] UINT Index,
        [annotation("_Out_")] GUID* pDecoderProfile );

    HRESULT CheckVideoDecoderFormat(
        [annotation("_In_")] const GUID* pDecoderProfile,
        [annotation("_In_")] DXGI_FORMAT Format,
        [annotation("_Out_")] BOOL* pSupported );

    HRESULT GetVideoDecoderConfigCount(
        [annotation("_In_")] const D3D11_VIDEO_DECODER_DESC* pDesc,
        [annotation("_Out_")] UINT* pCount );

    HRESULT GetVideoDecoderConfig(
        [annotation("_In_")] const D3D11_VIDEO_DECODER_DESC* pDesc,
        [annotation("_In_")] UINT Index,
        [annotation("_Out_")] D3D11_VIDEO_DECODER_CONFIG* pConfig );

    HRESULT GetContentProtectionCaps( 
        [annotation("_In_opt_")] const GUID* pCryptoType,
        [annotation("_In_opt_")] const GUID* pDecoderProfile,
        [annotation("_Out_")] D3D11_VIDEO_CONTENT_PROTECTION_CAPS* pCaps );

    HRESULT CheckCryptoKeyExchange(
        [annotation("_In_")] const GUID* pCryptoType,
        [annotation("_In_opt_")] const GUID* pDecoderProfile,
        [annotation("_In_")] UINT Index,
        [annotation("_Out_")] GUID* pKeyExchangeType );

    HRESULT SetPrivateData(
        [annotation("_In_")] REFGUID guid,
        [annotation("_In_")] UINT DataSize,
        [annotation("_In_reads_bytes_opt_(DataSize)")] const void* pData );

    HRESULT SetPrivateDataInterface(
        [annotation("_In_")] REFGUID guid,
        [annotation("_In_opt_")] const IUnknown* pData );
};



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Device
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

cpp_quote("#include <winapifamily.h>")

[ uuid( db6f6ddb-ac77-4e88-8253-819df9bbf140 ), object, local, pointer_default( unique ) ]
interface ID3D11Device
    : IUnknown
{
    // Create*
    HRESULT CreateBuffer(
        [annotation("_In_")] const D3D11_BUFFER_DESC* pDesc,
        [annotation("_In_opt_")] const D3D11_SUBRESOURCE_DATA* pInitialData,
        [annotation("_COM_Outptr_opt_")] ID3D11Buffer** ppBuffer );
    HRESULT CreateTexture1D(
        [annotation("_In_")] const D3D11_TEXTURE1D_DESC* pDesc,
        [annotation("_In_reads_opt_(_Inexpressible_(pDesc->MipLevels * pDesc->ArraySize))")] const D3D11_SUBRESOURCE_DATA* pInitialData,
        [annotation("_COM_Outptr_opt_")] ID3D11Texture1D** ppTexture1D );
    HRESULT CreateTexture2D(
        [annotation("_In_")] const D3D11_TEXTURE2D_DESC* pDesc,
        [annotation("_In_reads_opt_(_Inexpressible_(pDesc->MipLevels * pDesc->ArraySize))")] const D3D11_SUBRESOURCE_DATA* pInitialData,
        [annotation("_COM_Outptr_opt_")] ID3D11Texture2D** ppTexture2D );
    HRESULT CreateTexture3D(
        [annotation("_In_")] const D3D11_TEXTURE3D_DESC* pDesc,
        [annotation("_In_reads_opt_(_Inexpressible_(pDesc->MipLevels))")] const D3D11_SUBRESOURCE_DATA* pInitialData,
        [annotation("_COM_Outptr_opt_")] ID3D11Texture3D** ppTexture3D );
    HRESULT CreateShaderResourceView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_opt_")] const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11ShaderResourceView** ppSRView );
    HRESULT CreateUnorderedAccessView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_opt_")] const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11UnorderedAccessView** ppUAView );
    HRESULT CreateRenderTargetView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_opt_")] const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11RenderTargetView** ppRTView );
    HRESULT CreateDepthStencilView(
        [annotation("_In_")] ID3D11Resource* pResource,
        [annotation("_In_opt_")] const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11DepthStencilView** ppDepthStencilView );
    HRESULT CreateInputLayout(
        [annotation("_In_reads_(NumElements)")] const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs,
        [annotation("_In_range_( 0, D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT )")] UINT NumElements,
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecodeWithInputSignature,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_COM_Outptr_opt_")] ID3D11InputLayout** ppInputLayout );
    HRESULT CreateVertexShader(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11VertexShader** ppVertexShader );
    HRESULT CreateGeometryShader(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11GeometryShader** ppGeometryShader );
    HRESULT CreateGeometryShaderWithStreamOutput(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_reads_opt_(NumEntries)")] const D3D11_SO_DECLARATION_ENTRY* pSODeclaration,
        [annotation("_In_range_( 0, D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT )")] UINT NumEntries,
        [annotation("_In_reads_opt_(NumStrides)")] const UINT* pBufferStrides,
        [annotation("_In_range_( 0, D3D11_SO_BUFFER_SLOT_COUNT )")] UINT NumStrides,
        [annotation("_In_")] UINT RasterizedStream,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11GeometryShader** ppGeometryShader );
    HRESULT CreatePixelShader(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11PixelShader** ppPixelShader );
    HRESULT CreateHullShader(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11HullShader** ppHullShader );
    HRESULT CreateDomainShader(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11DomainShader** ppDomainShader );
    HRESULT CreateComputeShader(
        [annotation("_In_reads_(BytecodeLength)")] const void* pShaderBytecode,
        [annotation("_In_")] SIZE_T BytecodeLength,
        [annotation("_In_opt_")] ID3D11ClassLinkage* pClassLinkage,
        [annotation("_COM_Outptr_opt_")] ID3D11ComputeShader** ppComputeShader );
    HRESULT CreateClassLinkage(
        [annotation("_COM_Outptr_")] ID3D11ClassLinkage** ppLinkage);
    HRESULT CreateBlendState(
        [annotation("_In_")] const D3D11_BLEND_DESC* pBlendStateDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11BlendState** ppBlendState );
    HRESULT CreateDepthStencilState(
        [annotation("_In_")] const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11DepthStencilState** ppDepthStencilState );
    HRESULT CreateRasterizerState(
        [annotation("_In_")] const D3D11_RASTERIZER_DESC* pRasterizerDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11RasterizerState** ppRasterizerState );
    HRESULT CreateSamplerState(
        [annotation("_In_")] const D3D11_SAMPLER_DESC* pSamplerDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11SamplerState** ppSamplerState );
    HRESULT CreateQuery(
        [annotation("_In_")] const D3D11_QUERY_DESC* pQueryDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11Query** ppQuery );
    HRESULT CreatePredicate(
        [annotation("_In_")] const D3D11_QUERY_DESC* pPredicateDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11Predicate** ppPredicate );
    HRESULT CreateCounter(
        [annotation("_In_")] const D3D11_COUNTER_DESC* pCounterDesc,
        [annotation("_COM_Outptr_opt_")] ID3D11Counter** ppCounter );
    HRESULT CreateDeferredContext(
        UINT ContextFlags, // Reserved parameter; must be 0
        [annotation("_COM_Outptr_opt_")] ID3D11DeviceContext** ppDeferredContext );
    HRESULT OpenSharedResource(
        [annotation("_In_")] HANDLE hResource,
        [annotation("_In_")] REFIID ReturnedInterface,
        [annotation("_COM_Outptr_opt_")] void ** ppResource);

    // Check*
    HRESULT CheckFormatSupport(
        [annotation("_In_")] DXGI_FORMAT Format,
        [annotation("_Out_")] UINT* pFormatSupport );
    HRESULT CheckMultisampleQualityLevels(
        [annotation("_In_")] DXGI_FORMAT Format,
        [annotation("_In_")] UINT        SampleCount,
        [annotation("_Out_")] UINT* pNumQualityLevels );
    void CheckCounterInfo( [annotation("_Out_")] D3D11_COUNTER_INFO* pCounterInfo );
    HRESULT CheckCounter(
        [annotation("_In_")] const D3D11_COUNTER_DESC* pDesc,
        [annotation("_Out_")] D3D11_COUNTER_TYPE* pType,
        [annotation("_Out_")] UINT* pActiveCounters,
        [annotation("_Out_writes_opt_(*pNameLength)")] LPSTR szName,
        [annotation("_Inout_opt_")] UINT* pNameLength,
        [annotation("_Out_writes_opt_(*pUnitsLength)")] LPSTR szUnits,
        [annotation("_Inout_opt_")] UINT* pUnitsLength,
        [annotation("_Out_writes_opt_(*pDescriptionLength)")] LPSTR szDescription,
        [annotation("_Inout_opt_")] UINT* pDescriptionLength );
    HRESULT CheckFeatureSupport(
        D3D11_FEATURE Feature,
        [annotation("_Out_writes_bytes_(FeatureSupportDataSize)")] void* pFeatureSupportData,
        UINT FeatureSupportDataSize );

    HRESULT GetPrivateData(
        [annotation("_In_")] REFGUID guid,
        [annotation("_Inout_")] UINT* pDataSize,
        [annotation("_Out_writes_bytes_opt_(*pDataSize)")] void* pData );
    HRESULT SetPrivateData(
        [annotation("_In_")] REFGUID guid,
        [annotation("_In_")] UINT DataSize,
        [annotation("_In_reads_bytes_opt_(DataSize)")] const void* pData );
    HRESULT SetPrivateDataInterface(
        [annotation("_In_")] REFGUID guid,
        [annotation("_In_opt_")] const IUnknown* pData );

    D3D_FEATURE_LEVEL GetFeatureLevel();
    UINT GetCreationFlags();
    HRESULT GetDeviceRemovedReason();
    void GetImmediateContext( [annotation("_Outptr_")] ID3D11DeviceContext** ppImmediateContext );
    HRESULT SetExceptionMode( UINT RaiseFlags );
    UINT GetExceptionMode();
};


typedef enum D3D11_CREATE_DEVICE_FLAG
{
    D3D11_CREATE_DEVICE_SINGLETHREADED = 0x1,
    D3D11_CREATE_DEVICE_DEBUG = 0x2,
    D3D11_CREATE_DEVICE_SWITCH_TO_REF = 0x4,
    D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x8,
    D3D11_CREATE_DEVICE_BGRA_SUPPORT = 0x20,
    D3D11_CREATE_DEVICE_DEBUGGABLE = 0x40,
    D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x0080,
    D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT = 0x0100,
    D3D11_CREATE_DEVICE_VIDEO_SUPPORT = 0x0800,

} D3D11_CREATE_DEVICE_FLAG;

const UINT D3D11_SDK_VERSION = 7;


cpp_quote( "#if !defined( D3D11_IGNORE_SDK_LAYERS ) ")
cpp_quote( "#include \"d3d11sdklayers.h\" ")
cpp_quote( "#endif ")

cpp_quote( "#include \"d3d10_1.h\"" ) // 10_1.h must be included before any other d3d10 headers that would include d3d10.h
#pragma region Desktop Family
cpp_quote( "#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)")
cpp_quote( "#include \"d3d10shader.h\" ")
cpp_quote( "#include \"d3d10_1shader.h\" ")

cpp_quote( "#include \"d3d10misc.h\" ")

cpp_quote( "#include \"d3d10effect.h\" ")


cpp_quote( "#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */")
#pragma endregion


cpp_quote( "" )
cpp_quote( "///////////////////////////////////////////////////////////////////////////" )
cpp_quote( "// D3D11CreateDevice" )
cpp_quote( "// ------------------" )
cpp_quote( "//" )
cpp_quote( "// pAdapter" )
cpp_quote( "//      If NULL, D3D11CreateDevice will choose the primary adapter and" )
cpp_quote( "//      create a new instance from a temporarily created IDXGIFactory." )
cpp_quote( "//      If non-NULL, D3D11CreateDevice will register the appropriate" )
cpp_quote( "//      device, if necessary (via IDXGIAdapter::RegisterDrver), before" )
cpp_quote( "//      creating the device." )
cpp_quote( "// DriverType" )
cpp_quote( "//      Specifies the driver type to be created: hardware, reference or" )
cpp_quote( "//      null." )
cpp_quote( "// Software" )
cpp_quote( "//      HMODULE of a DLL implementing a software rasterizer. Must be NULL for" )
cpp_quote( "//      non-Software driver types." )
cpp_quote( "// Flags" )
cpp_quote( "//      Any of those documented for D3D11CreateDeviceAndSwapChain." )
cpp_quote( "// pFeatureLevels" )
cpp_quote( "//      Any of those documented for D3D11CreateDeviceAndSwapChain." )
cpp_quote( "// FeatureLevels" )
cpp_quote( "//      Size of feature levels array." )
cpp_quote( "// SDKVersion" )
cpp_quote( "//      SDK version. Use the D3D11_SDK_VERSION macro." )
cpp_quote( "// ppDevice" )
cpp_quote( "//      Pointer to returned interface. May be NULL." )
cpp_quote( "// pFeatureLevel" )
cpp_quote( "//      Pointer to returned feature level. May be NULL." )
cpp_quote( "// ppImmediateContext" )
cpp_quote( "//      Pointer to returned interface. May be NULL." )
cpp_quote( "//" )
cpp_quote( "// Return Values" )
cpp_quote( "//  Any of those documented for " )
cpp_quote( "//          CreateDXGIFactory1" )
cpp_quote( "//          IDXGIFactory::EnumAdapters" )
cpp_quote( "//          IDXGIAdapter::RegisterDriver" )
cpp_quote( "//          D3D11CreateDevice" )
cpp_quote( "//" )
cpp_quote( "///////////////////////////////////////////////////////////////////////////" )
cpp_quote( "typedef HRESULT (WINAPI* PFN_D3D11_CREATE_DEVICE)( _In_opt_ IDXGIAdapter*, " )
cpp_quote( "    D3D_DRIVER_TYPE, HMODULE, UINT, " )
cpp_quote( "    _In_reads_opt_( FeatureLevels ) CONST D3D_FEATURE_LEVEL*, " )
cpp_quote( "    UINT FeatureLevels, UINT, _COM_Outptr_opt_ ID3D11Device**, " )
cpp_quote( "    _Out_opt_ D3D_FEATURE_LEVEL*, _COM_Outptr_opt_ ID3D11DeviceContext** );" )
cpp_quote( "" )
cpp_quote( "HRESULT WINAPI D3D11CreateDevice(" )
cpp_quote( "    _In_opt_ IDXGIAdapter* pAdapter," )
cpp_quote( "    D3D_DRIVER_TYPE DriverType," )
cpp_quote( "    HMODULE Software," )
cpp_quote( "    UINT Flags," )
cpp_quote( "    _In_reads_opt_( FeatureLevels ) CONST D3D_FEATURE_LEVEL* pFeatureLevels," )
cpp_quote( "    UINT FeatureLevels," )
cpp_quote( "    UINT SDKVersion," )
cpp_quote( "    _COM_Outptr_opt_ ID3D11Device** ppDevice," )
cpp_quote( "    _Out_opt_ D3D_FEATURE_LEVEL* pFeatureLevel," )
cpp_quote( "    _COM_Outptr_opt_ ID3D11DeviceContext** ppImmediateContext );" )
cpp_quote( "" )

#pragma region Desktop Family
cpp_quote( "#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)")

cpp_quote( "///////////////////////////////////////////////////////////////////////////" )
cpp_quote( "// D3D11CreateDeviceAndSwapChain" )
cpp_quote( "// ------------------------------" )
cpp_quote( "//" )
cpp_quote( "// ppAdapter" )
cpp_quote( "//      If NULL, D3D11CreateDevice will choose the primary adapter and " )
cpp_quote( "//      create a new instance from a temporarily created IDXGIFactory." )
cpp_quote( "//      If non-NULL, D3D11CreateDevice will register the appropriate" )
cpp_quote( "//      device, if necessary (via IDXGIAdapter::RegisterDrver), before" )
cpp_quote( "//      creating the device." )
cpp_quote( "// DriverType" )
cpp_quote( "//      Specifies the driver type to be created: hardware, reference or" )
cpp_quote( "//      null." )
cpp_quote( "// Software" )
cpp_quote( "//      HMODULE of a DLL implementing a software rasterizer. Must be NULL for" )
cpp_quote( "//      non-Software driver types." )
cpp_quote( "// Flags" )
cpp_quote( "//      Any of those documented for D3D11CreateDevice." )
cpp_quote( "// pFeatureLevels" )
cpp_quote( "//      Array of any of the following:" )
cpp_quote( "//          D3D_FEATURE_LEVEL_11_0" )
cpp_quote( "//          D3D_FEATURE_LEVEL_10_1" )
cpp_quote( "//          D3D_FEATURE_LEVEL_10_0" )
cpp_quote( "//          D3D_FEATURE_LEVEL_9_3" )
cpp_quote( "//          D3D_FEATURE_LEVEL_9_2" )
cpp_quote( "//          D3D_FEATURE_LEVEL_9_1" )
cpp_quote( "//      Order indicates sequence in which instantiation will be attempted. If" )
cpp_quote( "//      NULL, then the implied order is the same as previously listed (i.e. " )
cpp_quote( "//      prefer most features available). " )
cpp_quote( "// FeatureLevels" )
cpp_quote( "//      Size of feature levels array." )
cpp_quote( "// SDKVersion" )
cpp_quote( "//      SDK version. Use the D3D11_SDK_VERSION macro." )
cpp_quote( "// pSwapChainDesc" )
cpp_quote( "//      Swap chain description, may be NULL." )
cpp_quote( "// ppSwapChain" )
cpp_quote( "//      Pointer to returned interface. May be NULL." )
cpp_quote( "// ppDevice" )
cpp_quote( "//      Pointer to returned interface. May be NULL." )
cpp_quote( "// pFeatureLevel" )
cpp_quote( "//      Pointer to returned feature level. May be NULL." )
cpp_quote( "// ppImmediateContext" )
cpp_quote( "//      Pointer to returned interface. May be NULL." )
cpp_quote( "//" )
cpp_quote( "// Return Values" )
cpp_quote( "//  Any of those documented for " )
cpp_quote( "//          CreateDXGIFactory1" )
cpp_quote( "//          IDXGIFactory::EnumAdapters" )
cpp_quote( "//          IDXGIAdapter::RegisterDriver" )
cpp_quote( "//          D3D11CreateDevice" )
cpp_quote( "//          IDXGIFactory::CreateSwapChain" )
cpp_quote( "//" )
cpp_quote( "///////////////////////////////////////////////////////////////////////////" )
cpp_quote( "typedef HRESULT (WINAPI* PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)( _In_opt_ IDXGIAdapter*, " )
cpp_quote( "    D3D_DRIVER_TYPE, HMODULE, UINT, " )
cpp_quote( "    _In_reads_opt_( FeatureLevels ) CONST D3D_FEATURE_LEVEL*, " )
cpp_quote( "    UINT FeatureLevels, UINT, _In_opt_ CONST DXGI_SWAP_CHAIN_DESC*, " )
cpp_quote( "    _COM_Outptr_opt_ IDXGISwapChain**, _COM_Outptr_opt_ ID3D11Device**, " )
cpp_quote( "    _Out_opt_ D3D_FEATURE_LEVEL*, _COM_Outptr_opt_ ID3D11DeviceContext** );" )
cpp_quote( "" )
cpp_quote( "HRESULT WINAPI D3D11CreateDeviceAndSwapChain(" )
cpp_quote( "    _In_opt_ IDXGIAdapter* pAdapter," )
cpp_quote( "    D3D_DRIVER_TYPE DriverType," )
cpp_quote( "    HMODULE Software," )
cpp_quote( "    UINT Flags," )
cpp_quote( "    _In_reads_opt_( FeatureLevels ) CONST D3D_FEATURE_LEVEL* pFeatureLevels," )
cpp_quote( "    UINT FeatureLevels," )
cpp_quote( "    UINT SDKVersion," )
cpp_quote( "    _In_opt_ CONST DXGI_SWAP_CHAIN_DESC* pSwapChainDesc," )
cpp_quote( "    _COM_Outptr_opt_ IDXGISwapChain** ppSwapChain," )
cpp_quote( "    _COM_Outptr_opt_ ID3D11Device** ppDevice," )
cpp_quote( "    _Out_opt_ D3D_FEATURE_LEVEL* pFeatureLevel," )
cpp_quote( "    _COM_Outptr_opt_ ID3D11DeviceContext** ppImmediateContext );" )
cpp_quote( "" )

cpp_quote( "#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */")
#pragma endregion

cpp_quote( "DEFINE_GUID(IID_ID3D11DeviceChild,0x1841e5c8,0x16b0,0x489b,0xbc,0xc8,0x44,0xcf,0xb0,0xd5,0xde,0xae);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11DepthStencilState,0x03823efb,0x8d8f,0x4e1c,0x9a,0xa2,0xf6,0x4b,0xb2,0xcb,0xfd,0xf1);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11BlendState,0x75b68faa,0x347d,0x4159,0x8f,0x45,0xa0,0x64,0x0f,0x01,0xcd,0x9a);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11RasterizerState,0x9bb4ab81,0xab1a,0x4d8f,0xb5,0x06,0xfc,0x04,0x20,0x0b,0x6e,0xe7);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Resource,0xdc8e63f3,0xd12b,0x4952,0xb4,0x7b,0x5e,0x45,0x02,0x6a,0x86,0x2d);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Buffer,0x48570b85,0xd1ee,0x4fcd,0xa2,0x50,0xeb,0x35,0x07,0x22,0xb0,0x37);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Texture1D,0xf8fb5c27,0xc6b3,0x4f75,0xa4,0xc8,0x43,0x9a,0xf2,0xef,0x56,0x4c);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Texture2D,0x6f15aaf2,0xd208,0x4e89,0x9a,0xb4,0x48,0x95,0x35,0xd3,0x4f,0x9c);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Texture3D,0x037e866e,0xf56d,0x4357,0xa8,0xaf,0x9d,0xab,0xbe,0x6e,0x25,0x0e);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11View,0x839d1216,0xbb2e,0x412b,0xb7,0xf4,0xa9,0xdb,0xeb,0xe0,0x8e,0xd1);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11ShaderResourceView,0xb0e06fe0,0x8192,0x4e1a,0xb1,0xca,0x36,0xd7,0x41,0x47,0x10,0xb2);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11RenderTargetView,0xdfdba067,0x0b8d,0x4865,0x87,0x5b,0xd7,0xb4,0x51,0x6c,0xc1,0x64);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11DepthStencilView,0x9fdac92a,0x1876,0x48c3,0xaf,0xad,0x25,0xb9,0x4f,0x84,0xa9,0xb6);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11UnorderedAccessView,0x28acf509,0x7f5c,0x48f6,0x86,0x11,0xf3,0x16,0x01,0x0a,0x63,0x80);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VertexShader,0x3b301d64,0xd678,0x4289,0x88,0x97,0x22,0xf8,0x92,0x8b,0x72,0xf3);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11HullShader,0x8e5c6061,0x628a,0x4c8e,0x82,0x64,0xbb,0xe4,0x5c,0xb3,0xd5,0xdd);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11DomainShader,0xf582c508,0x0f36,0x490c,0x99,0x77,0x31,0xee,0xce,0x26,0x8c,0xfa);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11GeometryShader,0x38325b96,0xeffb,0x4022,0xba,0x02,0x2e,0x79,0x5b,0x70,0x27,0x5c);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11PixelShader,0xea82e40d,0x51dc,0x4f33,0x93,0xd4,0xdb,0x7c,0x91,0x25,0xae,0x8c);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11ComputeShader,0x4f5b196e,0xc2bd,0x495e,0xbd,0x01,0x1f,0xde,0xd3,0x8e,0x49,0x69);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11InputLayout,0xe4819ddc,0x4cf0,0x4025,0xbd,0x26,0x5d,0xe8,0x2a,0x3e,0x07,0xb7);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11SamplerState,0xda6fea51,0x564c,0x4487,0x98,0x10,0xf0,0xd0,0xf9,0xb4,0xe3,0xa5);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Asynchronous,0x4b35d0cd,0x1e15,0x4258,0x9c,0x98,0x1b,0x13,0x33,0xf6,0xdd,0x3b);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Query,0xd6c00747,0x87b7,0x425e,0xb8,0x4d,0x44,0xd1,0x08,0x56,0x0a,0xfd);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Predicate,0x9eb576dd,0x9f77,0x4d86,0x81,0xaa,0x8b,0xab,0x5f,0xe4,0x90,0xe2);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Counter,0x6e8c49fb,0xa371,0x4770,0xb4,0x40,0x29,0x08,0x60,0x22,0xb7,0x41);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11ClassInstance,0xa6cd7faa,0xb0b7,0x4a2f,0x94,0x36,0x86,0x62,0xa6,0x57,0x97,0xcb);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11ClassLinkage,0xddf57cba,0x9543,0x46e4,0xa1,0x2b,0xf2,0x07,0xa0,0xfe,0x7f,0xed);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11CommandList,0xa24bc4d1,0x769e,0x43f7,0x80,0x13,0x98,0xff,0x56,0x6c,0x18,0xe2);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11DeviceContext,0xc0bfa96c,0xe089,0x44fb,0x8e,0xaf,0x26,0xf8,0x79,0x61,0x90,0xda);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoDecoder,0x3C9C5B51,0x995D,0x48d1,0x9B,0x8D,0xFA,0x5C,0xAE,0xDE,0xD6,0x5C);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoProcessorEnumerator,0x31627037,0x53AB,0x4200,0x90,0x61,0x05,0xFA,0xA9,0xAB,0x45,0xF9);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoProcessor,0x1D7B0652,0x185F,0x41c6,0x85,0xCE,0x0C,0x5B,0xE3,0xD4,0xAE,0x6C);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11AuthenticatedChannel,0x3015A308,0xDCBD,0x47aa,0xA7,0x47,0x19,0x24,0x86,0xD1,0x4D,0x4A);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11CryptoSession,0x9B32F9AD,0xBDCC,0x40a6,0xA3,0x9D,0xD5,0xC8,0x65,0x84,0x57,0x20);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoDecoderOutputView,0xC2931AEA,0x2A85,0x4f20,0x86,0x0F,0xFB,0xA1,0xFD,0x25,0x6E,0x18);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoProcessorInputView,0x11EC5A5F,0x51DC,0x4945,0xAB,0x34,0x6E,0x8C,0x21,0x30,0x0E,0xA5);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoProcessorOutputView,0xA048285E,0x25A9,0x4527,0xBD,0x93,0xD6,0x8B,0x68,0xC4,0x42,0x54);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoContext,0x61F21C45,0x3C0E,0x4a74,0x9C,0xEA,0x67,0x10,0x0D,0x9A,0xD5,0xE4);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11VideoDevice,0x10EC4D5B,0x975A,0x4689,0xB9,0xE4,0xD0,0xAA,0xC3,0x0F,0xE3,0x33);" )
cpp_quote( "DEFINE_GUID(IID_ID3D11Device,0xdb6f6ddb,0xac77,0x4e88,0x82,0x53,0x81,0x9d,0xf9,0xbb,0xf1,0x40);" )
