diff --git a/build.rs b/build.rs index 622050495..564d07928 100644 --- a/build.rs +++ b/build.rs @@ -143,13 +143,13 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("d2d1svg", &["basetsd", "d2d1", "d2d1_1", "guiddef", "minwindef", "ntdef", "objidlbase", "winerror"], &[]), ("d2dbasetypes", &["d3d9types", "dcommon"], &[]), ("d3d", &[], &[]), - ("d3d10", &["d3dcommon"], &[]), - ("d3d10_1", &[], &[]), - ("d3d10_1shader", &[], &[]), - ("d3d10effect", &[], &[]), - ("d3d10misc", &[], &[]), - ("d3d10sdklayers", &[], &[]), - ("d3d10shader", &["d3d10", "d3dcommon", "minwindef", "unknwnbase", "winnt"], &[]), + ("d3d10", &["basetsd", "d3dcommon", "dxgiformat", "dxgitype", "guiddef", "minwindef", "unknwnbase", "windef", "winnt"], &[]), + ("d3d10_1", &["basetsd", "d3d10", "d3d10misc", "d3dcommon", "dxgi", "dxgiformat", "minwindef", "winnt"], &[]), + ("d3d10_1shader", &["d3d10", "d3d10shader", "minwindef", "winnt"], &[]), + ("d3d10effect", &["basetsd", "d3d10", "d3d10shader", "d3dcommon", "minwindef", "unknwnbase", "winnt"], &[]), + ("d3d10misc", &["d3d10", "dxgi", "minwindef", "winnt"], &[]), + ("d3d10sdklayers", &["basetsd", "dxgi", "minwindef", "unknwnbase", "winnt"], &[]), + ("d3d10shader", &["basetsd", "d3d10", "d3dcommon", "minwindef", "unknwnbase", "winnt"], &[]), ("d3d11", &["basetsd", "d3dcommon", "dxgi", "dxgiformat", "dxgitype", "guiddef", "minwindef", "unknwnbase", "windef", "winnt"], &["d3d11"]), ("d3d11_1", &["basetsd", "d3d11", "d3dcommon", "dxgiformat", "dxgitype", "guiddef", "minwindef", "unknwnbase", "winnt"], &[]), ("d3d11_2", &["basetsd", "d3d11", "d3d11_1", "dxgiformat", "minwindef", "winnt"], &[]), diff --git a/src/um/d3d10.rs b/src/um/d3d10.rs index 887b7a344..e314f3684 100644 --- a/src/um/d3d10.rs +++ b/src/um/d3d10.rs @@ -3,10 +3,1437 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. +use ctypes::{c_long, c_void}; +use shared::basetsd::{SIZE_T, UINT64, UINT8}; +use shared::dxgiformat::DXGI_FORMAT; +use shared::dxgitype::DXGI_SAMPLE_DESC; +use shared::guiddef::{REFGUID, REFIID}; +use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, UINT}; +use shared::windef::RECT; use um::d3dcommon::{D3D_PRIMITIVE, D3D_PRIMITIVE_TOPOLOGY, D3D_SRV_DIMENSION}; +use um::unknwnbase::{IUnknown, IUnknownVtbl}; +use um::winnt::{HANDLE, HRESULT, INT, LPCSTR, LPSTR}; +pub const D3D10_16BIT_INDEX_STRIP_CUT_VALUE: DWORD = 0xffff; +pub const D3D10_32BIT_INDEX_STRIP_CUT_VALUE: DWORD = 0xffffffff; +pub const D3D10_8BIT_INDEX_STRIP_CUT_VALUE: DWORD = 0xff; +pub const D3D10_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT: DWORD = 9; +pub const D3D10_CLIP_OR_CULL_DISTANCE_COUNT: DWORD = 8; +pub const D3D10_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT: DWORD = 2; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT: DWORD = 14; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS: DWORD = 4; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT: DWORD = 15; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT: DWORD = 15; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST: DWORD = 1; +pub const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT: DWORD = 64; +pub const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT: DWORD = 1; +pub const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST: DWORD = 1; +pub const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS: DWORD = 1; +pub const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT: DWORD = 128; +pub const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST: DWORD = 1; +pub const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT: DWORD = 128; +pub const D3D10_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS: DWORD = 1; +pub const D3D10_COMMONSHADER_SAMPLER_REGISTER_COUNT: DWORD = 16; +pub const D3D10_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST: DWORD = 1; +pub const D3D10_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT: DWORD = 16; +pub const D3D10_COMMONSHADER_SUBROUTINE_NESTING_LIMIT: DWORD = 32; +pub const D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_COMMONSHADER_TEMP_REGISTER_COUNT: DWORD = 4096; +pub const D3D10_COMMONSHADER_TEMP_REGISTER_READS_PER_INST: DWORD = 3; +pub const D3D10_COMMONSHADER_TEMP_REGISTER_READ_PORTS: DWORD = 3; +pub const D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX: DWORD = 10; +pub const D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN: c_long = -10; +pub const D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE: c_long = -8; +pub const D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE: DWORD = 7; +pub const D3D10_DEFAULT_BLEND_FACTOR_ALPHA: FLOAT = 1.0; +pub const D3D10_DEFAULT_BLEND_FACTOR_BLUE: FLOAT = 1.0; +pub const D3D10_DEFAULT_BLEND_FACTOR_GREEN: FLOAT = 1.0; +pub const D3D10_DEFAULT_BLEND_FACTOR_RED: FLOAT = 1.0; +pub const D3D10_DEFAULT_BORDER_COLOR_COMPONENT: FLOAT = 0.0; +pub const D3D10_DEFAULT_DEPTH_BIAS: DWORD = 0; +pub const D3D10_DEFAULT_DEPTH_BIAS_CLAMP: FLOAT = 0.0; +pub const D3D10_DEFAULT_MAX_ANISOTROPY: FLOAT = 16.0; +pub const D3D10_DEFAULT_MIP_LOD_BIAS: FLOAT = 0.0; +pub const D3D10_DEFAULT_RENDER_TARGET_ARRAY_INDEX: DWORD = 0; +pub const D3D10_DEFAULT_SAMPLE_MASK: DWORD = 0xffffffff; +pub const D3D10_DEFAULT_SCISSOR_ENDX: DWORD = 0; +pub const D3D10_DEFAULT_SCISSOR_ENDY: DWORD = 0; +pub const D3D10_DEFAULT_SCISSOR_STARTX: DWORD = 0; +pub const D3D10_DEFAULT_SCISSOR_STARTY: DWORD = 0; +pub const D3D10_DEFAULT_SLOPE_SCALED_DEPTH_BIAS: FLOAT = 0.0; +pub const D3D10_DEFAULT_STENCIL_READ_MASK: DWORD = 0xff; +pub const D3D10_DEFAULT_STENCIL_REFERENCE: DWORD = 0; +pub const D3D10_DEFAULT_STENCIL_WRITE_MASK: DWORD = 0xff; +pub const D3D10_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX: DWORD = 0; +pub const D3D10_DEFAULT_VIEWPORT_HEIGHT: DWORD = 0; +pub const D3D10_DEFAULT_VIEWPORT_MAX_DEPTH: FLOAT = 0.0; +pub const D3D10_DEFAULT_VIEWPORT_MIN_DEPTH: FLOAT = 0.0; +pub const D3D10_DEFAULT_VIEWPORT_TOPLEFTX: DWORD = 0; +pub const D3D10_DEFAULT_VIEWPORT_TOPLEFTY: DWORD = 0; +pub const D3D10_DEFAULT_VIEWPORT_WIDTH: DWORD = 0; +pub const D3D10_FLOAT16_FUSED_TOLERANCE_IN_ULP: FLOAT = 0.6; +pub const D3D10_FLOAT32_MAX: FLOAT = 3.402823466e+38; +pub const D3D10_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP: FLOAT = 0.6; +pub const D3D10_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR: FLOAT = 2.4; +pub const D3D10_FLOAT_TO_SRGB_EXPONENT_NUMERATOR: FLOAT = 1.0; +pub const D3D10_FLOAT_TO_SRGB_OFFSET: FLOAT = 0.055; +pub const D3D10_FLOAT_TO_SRGB_SCALE_1: FLOAT = 12.92; +pub const D3D10_FLOAT_TO_SRGB_SCALE_2: FLOAT = 1.055; +pub const D3D10_FLOAT_TO_SRGB_THRESHOLD: FLOAT = 0.0031308; +pub const D3D10_FTOI_INSTRUCTION_MAX_INPUT: FLOAT = 2147483647.999; +pub const D3D10_FTOI_INSTRUCTION_MIN_INPUT: FLOAT = -2147483648.999; +pub const D3D10_FTOU_INSTRUCTION_MAX_INPUT: FLOAT = 4294967295.999; +pub const D3D10_FTOU_INSTRUCTION_MIN_INPUT: FLOAT = 0.0; +pub const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS: DWORD = 1; +pub const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COUNT: DWORD = 1; +pub const D3D10_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST: DWORD = 2; +pub const D3D10_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_GS_INPUT_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_GS_INPUT_REGISTER_COUNT: DWORD = 16; +pub const D3D10_GS_INPUT_REGISTER_READS_PER_INST: DWORD = 2; +pub const D3D10_GS_INPUT_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_GS_INPUT_REGISTER_VERTICES: DWORD = 6; +pub const D3D10_GS_OUTPUT_ELEMENTS: DWORD = 32; +pub const D3D10_GS_OUTPUT_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_GS_OUTPUT_REGISTER_COUNT: DWORD = 32; +pub const D3D10_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES: DWORD = 0; +pub const D3D10_IA_DEFAULT_PRIMITIVE_TOPOLOGY: DWORD = 0; +pub const D3D10_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES: DWORD = 0; +pub const D3D10_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT: DWORD = 1; +pub const D3D10_IA_INSTANCE_ID_BIT_COUNT: DWORD = 32; +pub const D3D10_IA_INTEGER_ARITHMETIC_BIT_COUNT: DWORD = 32; +pub const D3D10_IA_PRIMITIVE_ID_BIT_COUNT: DWORD = 32; +pub const D3D10_IA_VERTEX_ID_BIT_COUNT: DWORD = 32; +pub const D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT: DWORD = 16; +pub const D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS: DWORD = 64; +pub const D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT: DWORD = 16; +pub const D3D10_INTEGER_DIVIDE_BY_ZERO_QUOTIENT: DWORD = 0xffffffff; +pub const D3D10_INTEGER_DIVIDE_BY_ZERO_REMAINDER: DWORD = 0xffffffff; +pub const D3D10_LINEAR_GAMMA: FLOAT = 1.0; +pub const D3D10_MAX_BORDER_COLOR_COMPONENT: FLOAT = 1.0; +pub const D3D10_MAX_DEPTH: FLOAT = 1.0; +pub const D3D10_MAX_MAXANISOTROPY: DWORD = 16; +pub const D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT: DWORD = 32; +pub const D3D10_MAX_POSITION_VALUE: FLOAT = 3.402823466e+34; +pub const D3D10_MAX_TEXTURE_DIMENSION_2_TO_EXP: DWORD = 17; +pub const D3D10_MIN_BORDER_COLOR_COMPONENT: FLOAT = 0.0; +pub const D3D10_MIN_DEPTH: FLOAT = 0.0; +pub const D3D10_MIN_MAXANISOTROPY: DWORD = 0; +pub const D3D10_MIP_LOD_BIAS_MAX: FLOAT = 15.99; +pub const D3D10_MIP_LOD_BIAS_MIN: FLOAT = -16.0; +pub const D3D10_MIP_LOD_FRACTIONAL_BIT_COUNT: DWORD = 6; +pub const D3D10_MIP_LOD_RANGE_BIT_COUNT: DWORD = 8; +pub const D3D10_MULTISAMPLE_ANTIALIAS_LINE_WIDTH: FLOAT = 1.4; +pub const D3D10_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT: DWORD = 0; +pub const D3D10_PIXEL_ADDRESS_RANGE_BIT_COUNT: DWORD = 13; +pub const D3D10_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT: DWORD = 15; +pub const D3D10_PS_FRONTFACING_DEFAULT_VALUE: DWORD = 0xffffffff; +pub const D3D10_PS_FRONTFACING_FALSE_VALUE: DWORD = 0; +pub const D3D10_PS_FRONTFACING_TRUE_VALUE: DWORD = 0xffffffff; +pub const D3D10_PS_INPUT_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_PS_INPUT_REGISTER_COUNT: DWORD = 32; +pub const D3D10_PS_INPUT_REGISTER_READS_PER_INST: DWORD = 2; +pub const D3D10_PS_INPUT_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT: FLOAT = 0.0; +pub const D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS: DWORD = 1; +pub const D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_PS_OUTPUT_DEPTH_REGISTER_COUNT: DWORD = 1; +pub const D3D10_PS_OUTPUT_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_PS_OUTPUT_REGISTER_COUNT: DWORD = 8; +pub const D3D10_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT: FLOAT = 0.5; +pub const D3D10_REQ_BLEND_OBJECT_COUNT_PER_CONTEXT: DWORD = 4096; +pub const D3D10_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP: DWORD = 27; +pub const D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT: DWORD = 4096; +pub const D3D10_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_CONTEXT: DWORD = 4096; +pub const D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP: DWORD = 32; +pub const D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP: DWORD = 32; +pub const D3D10_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION: DWORD = 8192; +pub const D3D10_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT: DWORD = 1024; +pub const D3D10_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT: DWORD = 4096; +pub const D3D10_REQ_MAXANISOTROPY: DWORD = 16; +pub const D3D10_REQ_MIP_LEVELS: DWORD = 14; +pub const D3D10_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES: DWORD = 2048; +pub const D3D10_REQ_RASTERIZER_OBJECT_COUNT_PER_CONTEXT: DWORD = 4096; +pub const D3D10_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH: DWORD = 8192; +pub const D3D10_REQ_RESOURCE_SIZE_IN_MEGABYTES: DWORD = 128; +pub const D3D10_REQ_RESOURCE_VIEW_COUNT_PER_CONTEXT_2_TO_EXP: DWORD = 20; +pub const D3D10_REQ_SAMPLER_OBJECT_COUNT_PER_CONTEXT: DWORD = 4096; +pub const D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION: DWORD = 512; +pub const D3D10_REQ_TEXTURE1D_U_DIMENSION: DWORD = 8192; +pub const D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION: DWORD = 512; +pub const D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION: DWORD = 8192; +pub const D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION: DWORD = 2048; +pub const D3D10_REQ_TEXTURECUBE_DIMENSION: DWORD = 8192; +pub const D3D10_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL: DWORD = 0; +pub const D3D10_SHADER_MAJOR_VERSION: DWORD = 4; +pub const D3D10_SHADER_MINOR_VERSION: DWORD = 0; +pub const D3D10_SHIFT_INSTRUCTION_PAD_VALUE: DWORD = 0; +pub const D3D10_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT: DWORD = 5; +pub const D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT: DWORD = 8; +pub const D3D10_SO_BUFFER_MAX_STRIDE_IN_BYTES: DWORD = 2048; +pub const D3D10_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES: DWORD = 256; +pub const D3D10_SO_BUFFER_SLOT_COUNT: DWORD = 4; +pub const D3D10_SO_DDI_REGISTER_INDEX_DENOTING_GAP: DWORD = 0xffffffff; +pub const D3D10_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER: DWORD = 1; +pub const D3D10_SO_SINGLE_BUFFER_COMPONENT_LIMIT: DWORD = 64; +pub const D3D10_SRGB_GAMMA: FLOAT = 2.2; +pub const D3D10_SRGB_TO_FLOAT_DENOMINATOR_1: FLOAT = 12.92; +pub const D3D10_SRGB_TO_FLOAT_DENOMINATOR_2: FLOAT = 1.055; +pub const D3D10_SRGB_TO_FLOAT_EXPONENT: FLOAT = 2.4; +pub const D3D10_SRGB_TO_FLOAT_OFFSET: FLOAT = 0.055; +pub const D3D10_SRGB_TO_FLOAT_THRESHOLD: FLOAT = 0.04045; +pub const D3D10_SRGB_TO_FLOAT_TOLERANCE_IN_ULP: FLOAT = 0.5; +pub const D3D10_STANDARD_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_STANDARD_COMPONENT_BIT_COUNT_DOUBLED: DWORD = 64; +pub const D3D10_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE: DWORD = 4; +pub const D3D10_STANDARD_PIXEL_COMPONENT_COUNT: DWORD = 128; +pub const D3D10_STANDARD_PIXEL_ELEMENT_COUNT: DWORD = 32; +pub const D3D10_STANDARD_VECTOR_SIZE: DWORD = 4; +pub const D3D10_STANDARD_VERTEX_ELEMENT_COUNT: DWORD = 16; +pub const D3D10_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT: DWORD = 64; +pub const D3D10_SUBPIXEL_FRACTIONAL_BIT_COUNT: DWORD = 8; +pub const D3D10_SUBTEXEL_FRACTIONAL_BIT_COUNT: DWORD = 6; +pub const D3D10_TEXEL_ADDRESS_RANGE_BIT_COUNT: DWORD = 18; +pub const D3D10_UNBOUND_MEMORY_ACCESS_RESULT: DWORD = 0; +pub const D3D10_VIEWPORT_AND_SCISSORRECT_MAX_INDEX: DWORD = 15; +pub const D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE: DWORD = 16; +pub const D3D10_VIEWPORT_BOUNDS_MAX: DWORD = 16383; +pub const D3D10_VIEWPORT_BOUNDS_MIN: c_long = -16384; +pub const D3D10_VS_INPUT_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_VS_INPUT_REGISTER_COUNT: DWORD = 16; +pub const D3D10_VS_INPUT_REGISTER_READS_PER_INST: DWORD = 2; +pub const D3D10_VS_INPUT_REGISTER_READ_PORTS: DWORD = 1; +pub const D3D10_VS_OUTPUT_REGISTER_COMPONENTS: DWORD = 4; +pub const D3D10_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_VS_OUTPUT_REGISTER_COUNT: DWORD = 16; +pub const D3D10_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT: DWORD = 10; +pub const D3D10_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP: DWORD = 25; +pub const D3D10_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP: DWORD = 25; +pub const D3D_MAJOR_VERSION: DWORD = 10; +pub const D3D_MINOR_VERSION: DWORD = 0; +pub const D3D_SPEC_DATE_DAY: DWORD = 8; +pub const D3D_SPEC_DATE_MONTH: DWORD = 8; +pub const D3D_SPEC_DATE_YEAR: DWORD = 2006; +pub const D3D_SPEC_VERSION: FLOAT = 1.050005; +ENUM!{enum D3D10_INPUT_CLASSIFICATION { + D3D10_INPUT_PER_VERTEX_DATA = 0, + D3D10_INPUT_PER_INSTANCE_DATA = 1, +}} +pub const D3D10_APPEND_ALIGNED_ELEMENT: DWORD = 0xffffffff; +STRUCT!{struct D3D10_INPUT_ELEMENT_DESC { + SemanticName: LPCSTR, + SemanticIndex: UINT, + Format: DXGI_FORMAT, + InputSlot: UINT, + AlignedByteOffset: UINT, + InputSlotClass: D3D10_INPUT_CLASSIFICATION, + InstanceDataStepRate: UINT, +}} +ENUM!{enum D3D10_FILL_MODE { + D3D10_FILL_WIREFRAME = 2, + D3D10_FILL_SOLID = 3, +}} pub type D3D10_PRIMITIVE_TOPOLOGY = D3D_PRIMITIVE_TOPOLOGY; pub type D3D10_PRIMITIVE = D3D_PRIMITIVE; +ENUM!{enum D3D10_CULL_MODE { + D3D10_CULL_NONE = 1, + D3D10_CULL_FRONT = 2, + D3D10_CULL_BACK = 3, +}} +STRUCT!{struct D3D10_SO_DECLARATION_ENTRY { + SemanticName: LPCSTR, + SemanticIndex: UINT, + StartComponent: BYTE, + ComponentCount: BYTE, + OutputSlot: BYTE, +}} +STRUCT!{struct D3D10_VIEWPORT { + TopLeftX: INT, + TopLeftY: INT, + Width: UINT, + Height: UINT, + MinDepth: FLOAT, + MaxDepth: FLOAT, +}} +ENUM!{enum D3D10_RESOURCE_DIMENSION { + D3D10_RESOURCE_DIMENSION_UNKNOWN = 0, + D3D10_RESOURCE_DIMENSION_BUFFER = 1, + D3D10_RESOURCE_DIMENSION_TEXTURE1D = 2, + D3D10_RESOURCE_DIMENSION_TEXTURE2D = 3, + D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4, +}} pub type D3D10_SRV_DIMENSION = D3D_SRV_DIMENSION; +ENUM!{enum D3D10_DSV_DIMENSION { + D3D10_DSV_DIMENSION_UNKNOWN = 0, + D3D10_DSV_DIMENSION_TEXTURE1D = 1, + D3D10_DSV_DIMENSION_TEXTURE1DARRAY = 2, + D3D10_DSV_DIMENSION_TEXTURE2D = 3, + D3D10_DSV_DIMENSION_TEXTURE2DARRAY = 4, + D3D10_DSV_DIMENSION_TEXTURE2DMS = 5, + D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY = 6, +}} +ENUM!{enum D3D10_RTV_DIMENSION { + D3D10_RTV_DIMENSION_UNKNOWN = 0, + D3D10_RTV_DIMENSION_BUFFER = 1, + D3D10_RTV_DIMENSION_TEXTURE1D = 2, + D3D10_RTV_DIMENSION_TEXTURE1DARRAY = 3, + D3D10_RTV_DIMENSION_TEXTURE2D = 4, + D3D10_RTV_DIMENSION_TEXTURE2DARRAY = 5, + D3D10_RTV_DIMENSION_TEXTURE2DMS = 6, + D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY = 7, + D3D10_RTV_DIMENSION_TEXTURE3D = 8, +}} +ENUM!{enum D3D10_USAGE { + D3D10_USAGE_DEFAULT = 0, + D3D10_USAGE_IMMUTABLE = 1, + D3D10_USAGE_DYNAMIC = 2, + D3D10_USAGE_STAGING = 3, +}} +ENUM!{enum D3D10_BIND_FLAG { + D3D10_BIND_VERTEX_BUFFER = 0x1, + D3D10_BIND_INDEX_BUFFER = 0x2, + D3D10_BIND_CONSTANT_BUFFER = 0x4, + D3D10_BIND_SHADER_RESOURCE = 0x8, + D3D10_BIND_STREAM_OUTPUT = 0x10, + D3D10_BIND_RENDER_TARGET = 0x20, + D3D10_BIND_DEPTH_STENCIL = 0x40, +}} +ENUM!{enum D3D10_CPU_ACCESS_FLAG { + D3D10_CPU_ACCESS_WRITE = 0x10000, + D3D10_CPU_ACCESS_READ = 0x20000, +}} +ENUM!{enum D3D10_MAP { + D3D10_MAP_READ = 1, + D3D10_MAP_WRITE = 2, + D3D10_MAP_READ_WRITE = 3, + D3D10_MAP_WRITE_DISCARD = 4, + D3D10_MAP_WRITE_NO_OVERWRITE = 5, +}} +ENUM!{enum D3D10_MAP_FLAG { + D3D10_MAP_FLAG_DO_NOT_WAIT = 0x100000, +}} +ENUM!{enum D3D10_RAISE_FLAG { + D3D10_RAISE_FLAG_DRIVER_INTERNAL_ERROR = 0x1, +}} +ENUM!{enum D3D10_CLEAR_FLAG { + D3D10_CLEAR_DEPTH = 0x1, + D3D10_CLEAR_STENCIL = 0x2, +}} +pub type D3D10_RECT = RECT; +STRUCT!{struct D3D10_BOX { + left: UINT, + top: UINT, + front: UINT, + right: UINT, + bottom: UINT, + back: UINT, +}} +RIDL!{#[uuid(0x9b7e4c00, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10DeviceChild(ID3D10DeviceChildVtbl): IUnknown(IUnknownVtbl) { + fn GetDevice( + ppDevice: *mut *mut ID3D10Device, + ) -> (), + fn GetPrivateData( + guid: REFGUID, + pDataSize: *mut UINT, + pData: *mut c_void, + ) -> HRESULT, + fn SetPrivateData( + guid: REFGUID, + DataSize: UINT, + pData: *const c_void, + ) -> HRESULT, + fn SetPrivateDataInterface( + guid: REFGUID, + pData: *const IUnknown, + ) -> HRESULT, +}} +ENUM!{enum D3D10_COMPARISON_FUNC { + D3D10_COMPARISON_NEVER = 1, + D3D10_COMPARISON_LESS = 2, + D3D10_COMPARISON_EQUAL = 3, + D3D10_COMPARISON_LESS_EQUAL = 4, + D3D10_COMPARISON_GREATER = 5, + D3D10_COMPARISON_NOT_EQUAL = 6, + D3D10_COMPARISON_GREATER_EQUAL = 7, + D3D10_COMPARISON_ALWAYS = 8, +}} +ENUM!{enum D3D10_DEPTH_WRITE_MASK { + D3D10_DEPTH_WRITE_MASK_ZERO = 0, + D3D10_DEPTH_WRITE_MASK_ALL = 1, +}} +ENUM!{enum D3D10_STENCIL_OP { + D3D10_STENCIL_OP_KEEP = 1, + D3D10_STENCIL_OP_ZERO = 2, + D3D10_STENCIL_OP_REPLACE = 3, + D3D10_STENCIL_OP_INCR_SAT = 4, + D3D10_STENCIL_OP_DECR_SAT = 5, + D3D10_STENCIL_OP_INVERT = 6, + D3D10_STENCIL_OP_INCR = 7, + D3D10_STENCIL_OP_DECR = 8, +}} +STRUCT!{struct D3D10_DEPTH_STENCILOP_DESC +{ + StencilFailOp: D3D10_STENCIL_OP, + StencilDepthFailOp: D3D10_STENCIL_OP, + StencilPassOp: D3D10_STENCIL_OP, + StencilFunc: D3D10_COMPARISON_FUNC, +}} +STRUCT!{struct D3D10_DEPTH_STENCIL_DESC { + DepthEnable: BOOL, + DepthWriteMask: D3D10_DEPTH_WRITE_MASK, + DepthFunc: D3D10_COMPARISON_FUNC, + StencilEnable: BOOL, + StencilReadMask: UINT8, + StencilWriteMask: UINT8, + FrontFace: D3D10_DEPTH_STENCILOP_DESC, + BackFace: D3D10_DEPTH_STENCILOP_DESC, +}} +RIDL!{#[uuid(0x2b4b1cc8, 0xa4ad, 0x41f8, 0x83, 0x22, 0xca, 0x86, 0xfc, 0x3e, 0xc6, 0x75)] +interface ID3D10DepthStencilState(ID3D10DepthStencilStateVtbl): + ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn GetDesc( + pDesc: *mut D3D10_DEPTH_STENCIL_DESC, + ) -> (), +}} +ENUM!{enum D3D10_BLEND { + D3D10_BLEND_ZERO = 1, + D3D10_BLEND_ONE = 2, + D3D10_BLEND_SRC_COLOR = 3, + D3D10_BLEND_INV_SRC_COLOR = 4, + D3D10_BLEND_SRC_ALPHA = 5, + D3D10_BLEND_INV_SRC_ALPHA = 6, + D3D10_BLEND_DEST_ALPHA = 7, + D3D10_BLEND_INV_DEST_ALPHA = 8, + D3D10_BLEND_DEST_COLOR = 9, + D3D10_BLEND_INV_DEST_COLOR = 10, + D3D10_BLEND_SRC_ALPHA_SAT = 11, + D3D10_BLEND_BLEND_FACTOR = 14, + D3D10_BLEND_INV_BLEND_FACTOR = 15, + D3D10_BLEND_SRC1_COLOR = 16, + D3D10_BLEND_INV_SRC1_COLOR = 17, + D3D10_BLEND_SRC1_ALPHA = 18, + D3D10_BLEND_INV_SRC1_ALPHA = 19, +}} +ENUM!{enum D3D10_BLEND_OP { + D3D10_BLEND_OP_ADD = 1, + D3D10_BLEND_OP_SUBTRACT = 2, + D3D10_BLEND_OP_REV_SUBTRACT = 3, + D3D10_BLEND_OP_MIN = 4, + D3D10_BLEND_OP_MAX = 5, +}} +ENUM!{enum D3D10_COLOR_WRITE_ENABLE { + D3D10_COLOR_WRITE_ENABLE_RED = 1, + D3D10_COLOR_WRITE_ENABLE_GREEN = 2, + D3D10_COLOR_WRITE_ENABLE_BLUE = 4, + D3D10_COLOR_WRITE_ENABLE_ALPHA = 8, + D3D10_COLOR_WRITE_ENABLE_ALL = D3D10_COLOR_WRITE_ENABLE_RED | D3D10_COLOR_WRITE_ENABLE_GREEN + | D3D10_COLOR_WRITE_ENABLE_BLUE | D3D10_COLOR_WRITE_ENABLE_ALPHA, +}} +STRUCT!{struct D3D10_BLEND_DESC { + AlphaToCoverageEnable: BOOL, + BlendEnable: [BOOL; 8], + SrcBlend: D3D10_BLEND, + DestBlend: D3D10_BLEND, + BlendOp: D3D10_BLEND_OP, + SrcBlendAlpha: D3D10_BLEND, + DestBlendAlpha: D3D10_BLEND, + BlendOpAlpha: D3D10_BLEND_OP, + RenderTargetWriteMask: [UINT8; 8], +}} +RIDL!{#[uuid(0xedad8d19, 0x8a35, 0x4d6d, 0x85, 0x66, 0x2e, 0xa2, 0x76, 0xcd, 0xe1, 0x61)] +interface ID3D10BlendState(ID3D10BlendStateVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn GetDesc( + pDesc: *mut D3D10_BLEND_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_RASTERIZER_DESC { + FillMode: D3D10_FILL_MODE, + CullMode: D3D10_CULL_MODE, + FrontCounterClockwise: BOOL, + DepthBias: INT, + DepthBiasClamp: FLOAT, + SlopeScaledDepthBias: FLOAT, + DepthClipEnable: BOOL, + ScissorEnable: BOOL, + MultisampleEnable: BOOL, + AntialiasedLineEnable: BOOL, +}} +RIDL!{#[uuid(0xa2a07292, 0x89af, 0x4345, 0xbe, 0x2e, 0xc5, 0x3d, 0x9f, 0xbb, 0x6e, 0x9f)] +interface ID3D10RasterizerState(ID3D10RasterizerStateVtbl): + ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn GetDesc( + pDesc: *mut D3D10_RASTERIZER_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_SUBRESOURCE_DATA { + pSysMem: *mut c_void, + SysMemPitch: UINT, + SysMemSlicePitch: UINT, +}} +RIDL!{#[uuid(0x9b7e4c01, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Resource(ID3D10ResourceVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn GetType( + rType: *mut D3D10_RESOURCE_DIMENSION, + ) -> (), + fn SetEvictionPriority( + EvictionPriority: UINT, + ) -> (), + fn GetEvictionPriority() -> UINT, +}} +STRUCT!{struct D3D10_BUFFER_DESC { + ByteWidth: UINT, + Usage: D3D10_USAGE, + BindFlags: UINT, + CPUAccessFlags: UINT, + MiscFlags: UINT, +}} +RIDL!{#[uuid(0x9b7e4c02, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Buffer(ID3D10BufferVtbl): ID3D10Resource(ID3D10ResourceVtbl) { + fn Map( + MapType: D3D10_MAP, + MapFlags: UINT, + ppData: *mut *mut c_void, + ) -> HRESULT, + fn Unmap() -> (), + fn GetDesc( + pDesc: *mut D3D10_BUFFER_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_TEXTURE1D_DESC { + Width: UINT, + MipLevels: UINT, + ArraySize: UINT, + Format: DXGI_FORMAT, + Usage: D3D10_USAGE, + BindFlags: UINT, + CPUAccessFlags: UINT, + MiscFlags: UINT, +}} +RIDL!{#[uuid(0x9b7e4c03, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Texture1D(ID3D10Texture1DVtbl): ID3D10Resource(ID3D10ResourceVtbl) { + fn Map( + Subresource: UINT, + MapType: D3D10_MAP, + MapFlags: UINT, + ppData: *mut *mut c_void, + ) -> (), + fn Unmap() -> (), + fn GetDesc( + pDesc: *mut D3D10_TEXTURE1D_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_TEXTURE2D_DESC { + Width: UINT, + Height: UINT, + ArraySize: UINT, + Format: DXGI_FORMAT, + SampleDesc: DXGI_SAMPLE_DESC, + Usage: D3D10_USAGE, + BindFlags: UINT, + CPUAccessFlags: UINT, + MiscFlags: UINT, +}} +STRUCT!{struct D3D10_MAPPED_TEXTURE2D { + pData: *mut c_void, + RowPitch: UINT, +}} +RIDL!{#[uuid(0x9b7e4c04, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Texture2D(ID3D10Texture2DVtbl): ID3D10Resource(ID3D10ResourceVtbl) { + fn Map( + Subresource: UINT, + MapType: D3D10_MAP, + MapFlags: UINT, + pMappedTex2D: *mut D3D10_MAPPED_TEXTURE2D, + ) -> (), + fn Unmap() -> (), + fn GetDesc( + pDesc: *mut D3D10_TEXTURE2D_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_TEXTURE3D_DESC { + Width: UINT, + Height: UINT, + Depth: UINT, + MipLevels: UINT, + Format: DXGI_FORMAT, + Usage: D3D10_USAGE, + BindFlags: UINT, + CPUAccessFlags: UINT, + MiscFlags: UINT, +}} +STRUCT!{struct D3D10_MAPPED_TEXTURE3D { + pData: *mut c_void, + RowPitch: UINT, + DepthPitch: UINT, +}} +RIDL!{#[uuid(0x9b7e4c05, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Texture3D(ID3D10Texture3DVtbl): ID3D10Resource(ID3D10ResourceVtbl) { + fn Map( + Subresource: UINT, + MapType: D3D10_MAP, + MapFlags: UINT, + pMappedTex3D: *mut D3D10_MAPPED_TEXTURE3D, + ) -> (), + fn Unmap() -> (), + fn GetDesc( + pDesc: *mut D3D10_TEXTURE3D_DESC, + ) -> (), +}} +ENUM!{enum D3D10_TEXTURECUBE_FACE { + D3D10_TEXTURECUBE_FACE_POSITIVE_X = 0, + D3D10_TEXTURECUBE_FACE_NEGATIVE_X = 1, + D3D10_TEXTURECUBE_FACE_POSITIVE_Y = 2, + D3D10_TEXTURECUBE_FACE_NEGATIVE_Y = 3, + D3D10_TEXTURECUBE_FACE_POSITIVE_Z = 4, + D3D10_TEXTURECUBE_FACE_NEGATIVE_Z = 5, +}} +RIDL!{#[uuid(0xc902b03f, 0x60a7, 0x49ba, 0x99, 0x36, 0x2a, 0x3a, 0xb3, 0x7a, 0x7e, 0x33)] +interface ID3D10View(ID3D10ViewVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn GetResource( + ppResource: *mut *mut ID3D10Resource, + ) -> (), +}} +UNION!{union D3D10_BUFFER_SRV_u1 { + [u32; 1], + FirstElement FirstElement_mut: UINT, + ElementOffset ElementOffset_mut: UINT, +}} +UNION!{union D3D10_BUFFER_SRV_u2 { + [u32; 1], + NumElements NumElements_mut: UINT, + ElementWidth ElementWidth_mut: UINT, +}} +STRUCT!{struct D3D10_BUFFER_SRV { + u1: D3D10_BUFFER_SRV_u1, + u2: D3D10_BUFFER_SRV_u2, +}} +STRUCT!{struct D3D10_TEX1D_SRV { + MostDetailedMip: UINT, + MipLevels: UINT, +}} +STRUCT!{struct D3D10_TEX1D_ARRAY_SRV { + MostDetailedMip: UINT, + MipLevels: UINT, + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX2D_SRV{ + MostDetailedMip: UINT, + MipLevels: UINT, +}} +STRUCT!{struct D3D10_TEX2D_ARRAY_SRV{ + MostDetailedMip: UINT, + MipLevels: UINT, + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX3D_SRV { + MostDetailedMip: UINT, + MipLevels: UINT, +}} +STRUCT!{struct D3D10_TEXCUBE_SRV { + MostDetailedMip: UINT, + MipLevels: UINT, +}} +STRUCT!{struct D3D10_TEX2DMS_SRV { + UnusedField_NothingToDefine: UINT, +}} +STRUCT!{struct D3D10_TEX2DMS_ARRAY_SRV { + FirstArraySlice: UINT, + ArraySize: UINT, +}} +UNION!{union D3D10_SHADER_RESOURCE_VIEW_DESC_u { + [u32; 4], + Buffer Buffer_mut: D3D10_BUFFER_SRV, + Texture1D Texture1D_mut: D3D10_TEX1D_SRV, + Texture1DArray Texture1DArray_mut: D3D10_TEX1D_ARRAY_SRV, + Texture2D Texture2D_mut: D3D10_TEX2D_SRV, + Texture2DArray Texture2DArray_mut: D3D10_TEX2D_ARRAY_SRV, + Texture2DMS Texture2DMS_mut: D3D10_TEX2DMS_SRV, + Texture2DMSArray Texture2DMSArray_mut: D3D10_TEX2DMS_ARRAY_SRV, + Texture3D Texture3D_mut: D3D10_TEX3D_SRV, + TextureCube TextureCube_mut: D3D10_TEXCUBE_SRV, +}} +STRUCT!{struct D3D10_SHADER_RESOURCE_VIEW_DESC { + Format: DXGI_FORMAT, + ViewDimension: D3D10_SRV_DIMENSION, + u: D3D10_SHADER_RESOURCE_VIEW_DESC_u , +}} +RIDL!{#[uuid(0x9b7e4c07, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10ShaderResourceView(ID3D10ShaderResourceViewVtbl): ID3D10View(ID3D10ViewVtbl) { + fn GetDesc( + pDesc: *mut D3D10_SHADER_RESOURCE_VIEW_DESC, + ) -> (), +}} +UNION!{union D3D10_BUFFER_RTV_u1 { + [u32; 1], + FirstElement FirstElement_mut: UINT, + ElementOffset ElementOffset_mut: UINT, +}} +UNION!{union D3D10_BUFFER_RTV_u2 { + [u32; 1], + NumElements NumElements_mut: UINT, + ElementWidth ElementWidth_mut: UINT, +}} +STRUCT!{struct D3D10_BUFFER_RTV { + u1: D3D10_BUFFER_RTV_u1, + u2: D3D10_BUFFER_RTV_u2, +}} +STRUCT!{struct D3D10_TEX1D_RTV { + MipSlice: UINT, +}} +STRUCT!{struct D3D10_TEX1D_ARRAY_RTV { + MipSlice: UINT, + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX2D_RTV { + MipSlice: UINT, +}} +STRUCT!{struct D3D10_TEX2DMS_RTV { + UnusedField_NothingToDefine: UINT, +}} +STRUCT!{struct D3D10_TEX2D_ARRAY_RTV { + MipSlice: UINT, + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX2DMS_ARRAY_RTV { + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX3D_RTV { + MipSlice: UINT, + FirstWSlice: UINT, + WSize: UINT, +}} +UNION!{union D3D10_RENDER_TARGET_VIEW_DESC_u { + [u32; 3], + Buffer Buffer_mut: D3D10_BUFFER_RTV, + Texture1D Texture1D_mut: D3D10_TEX1D_RTV, + Texture1DArray Texture1DArray_mut: D3D10_TEX1D_ARRAY_RTV, + Texture2D Texture2D_mut: D3D10_TEX2D_RTV, + Texture2DArray Texture2DArray_mut: D3D10_TEX2D_ARRAY_RTV, + Texture2DMS Texture2DMS_mut: D3D10_TEX2DMS_RTV, + Texture2DMSArray Texture2DMSArray_mut: D3D10_TEX2DMS_ARRAY_RTV, + Texture3D Texture3D_mut: D3D10_TEX3D_RTV, +}} +STRUCT!{struct D3D10_RENDER_TARGET_VIEW_DESC { + Format: DXGI_FORMAT, + ViewDimension: D3D10_RTV_DIMENSION, + u: D3D10_RENDER_TARGET_VIEW_DESC_u, +}} +RIDL!{#[uuid(0x9b7e4c08, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10RenderTargetView(ID3D10RenderTargetViewVtbl): ID3D10View(ID3D10ViewVtbl) { + fn GetDesc( + pDesc: *mut D3D10_RENDER_TARGET_VIEW_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_TEX1D_DSV { + MipSlice: UINT, +}} +STRUCT!{struct D3D10_TEX1D_ARRAY_DSV { + MipSlice: UINT, + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX2D_DSV { + MipSlice: UINT, +}} +STRUCT!{struct D3D10_TEX2D_ARRAY_DSV { + MipSlice: UINT, + FirstArraySlice: UINT, + ArraySize: UINT, +}} +STRUCT!{struct D3D10_TEX2DMS_DSV { + UnusedField_NothingToDefine: UINT, +}} +STRUCT!{struct D3D10_TEX2DMS_ARRAY_DSV { + FirstArraySlice: UINT, + ArraySize: UINT, +}} +UNION!{union D3D10_DEPTH_STENCIL_VIEW_DESC_u { + [u32; 3], + Texture1D Texture1D_mut: D3D10_TEX1D_DSV, + Texture1DArray Texture1DArray_mut: D3D10_TEX1D_ARRAY_DSV, + Texture2D Texture2D_mut: D3D10_TEX2D_DSV, + Texture2DArray Texture2DArray_mut: D3D10_TEX2D_ARRAY_DSV, + Texture2DMS Texture2DMS_mut: D3D10_TEX2DMS_DSV, + Texture2DMSArray Texture2DMSArray_mut: D3D10_TEX2DMS_ARRAY_DSV, +}} +STRUCT!{struct D3D10_DEPTH_STENCIL_VIEW_DESC { + Format: DXGI_FORMAT, + ViewDimension: D3D10_DSV_DIMENSION, + u: D3D10_DEPTH_STENCIL_VIEW_DESC_u, +}} +RIDL!{#[uuid(0x9b7e4c09, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10DepthStencilView(ID3D10DepthStencilViewVtbl): ID3D10View(ID3D10ViewVtbl) { + fn GetDesc( + pDesc: *mut D3D10_DEPTH_STENCIL_VIEW_DESC, + ) -> (), +}} +RIDL!{#[uuid(0x9b7e4c0a, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10VertexShader(ID3D10VertexShaderVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) {}} +RIDL!{#[uuid(0x6316be88, 0x54cd, 0x4040, 0xab, 0x44, 0x20, 0x46, 0x1b, 0xc8, 0x1f, 0x68)] +interface ID3D10GeometryShader(ID3D10GeometryShaderVtbl): + ID3D10DeviceChild(ID3D10DeviceChildVtbl) {}} +RIDL!{#[uuid(0x4968b601, 0x9d00, 0x4cde, 0x83, 0x46, 0x8e, 0x7f, 0x67, 0x58, 0x19, 0xb6)] +interface ID3D10PixelShader(ID3D10PixelShaderVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) {}} +RIDL!{#[uuid(0x9b7e4c0b, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10InputLayout(ID3D10InputLayoutVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) {}} +ENUM!{enum D3D10_FILTER { + D3D10_FILTER_MIN_MAG_MIP_POINT = 0, + D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1, + D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4, + D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5, + D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D3D10_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D10_FILTER_ANISOTROPIC = 0x55, + D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, + D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, + D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, + D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, + D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, + D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, + D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, + D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D10_FILTER_COMPARISON_ANISOTROPIC = 0xd5, + D3D10_FILTER_TEXT_1BIT = 0x80000000, +}} +ENUM!{enum D3D10_FILTER_TYPE { + D3D10_FILTER_TYPE_POINT = 0, + D3D10_FILTER_TYPE_LINEAR = 1, +}} +pub const D3D10_FILTER_TYPE_MASK: DWORD = 0x3; +pub const D3D10_MIN_FILTER_SHIFT: DWORD = 4; +pub const D3D10_MAG_FILTER_SHIFT: DWORD = 2; +pub const D3D10_MIP_FILTER_SHIFT: DWORD = 0; +pub const D3D10_COMPARISON_FILTERING_BIT: DWORD = 0x80; +pub const D3D10_ANISOTROPIC_FILTERING_BIT: DWORD = 0x40; +pub const D3D10_TEXT_1BIT_BIT: DWORD = 0x80000000; +ENUM!{enum D3D10_TEXTURE_ADDRESS_MODE { + D3D10_TEXTURE_ADDRESS_WRAP = 1, + D3D10_TEXTURE_ADDRESS_MIRROR = 2, + D3D10_TEXTURE_ADDRESS_CLAMP = 3, + D3D10_TEXTURE_ADDRESS_BORDER = 4, + D3D10_TEXTURE_ADDRESS_MIRROR_ONCE = 5, +}} +STRUCT!{struct D3D10_SAMPLER_DESC { + Filter: D3D10_FILTER, + AddressU: D3D10_TEXTURE_ADDRESS_MODE, + AddressV: D3D10_TEXTURE_ADDRESS_MODE, + AddressW: D3D10_TEXTURE_ADDRESS_MODE, + MipLODBias: FLOAT, + MaxAnisotropy: UINT, + ComparisonFunc: D3D10_COMPARISON_FUNC, + BorderColor: [FLOAT; 4], + MinLOD: FLOAT, + MaxLOD: FLOAT, +}} +RIDL!{#[uuid(0x9b7e4c0c, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10SamplerState(ID3D10SamplerStateVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn GetDesc( + pDesc: *mut D3D10_SAMPLER_DESC, + ) -> (), +}} +ENUM!{enum D3D10_FORMAT_SUPPORT { + D3D10_FORMAT_SUPPORT_BUFFER = 0x1, + D3D10_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x2, + D3D10_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x4, + D3D10_FORMAT_SUPPORT_SO_BUFFER = 0x8, + D3D10_FORMAT_SUPPORT_TEXTURE1D = 0x10, + D3D10_FORMAT_SUPPORT_TEXTURE2D = 0x20, + D3D10_FORMAT_SUPPORT_TEXTURE3D = 0x40, + D3D10_FORMAT_SUPPORT_TEXTURECUBE = 0x80, + D3D10_FORMAT_SUPPORT_SHADER_LOAD = 0x100, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE = 0x200, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x400, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x800, + D3D10_FORMAT_SUPPORT_MIP = 0x1000, + D3D10_FORMAT_SUPPORT_MIP_AUTOGEN = 0x2000, + D3D10_FORMAT_SUPPORT_RENDER_TARGET = 0x4000, + D3D10_FORMAT_SUPPORT_BLENDABLE = 0x8000, + D3D10_FORMAT_SUPPORT_DEPTH_STENCIL = 0x10000, + D3D10_FORMAT_SUPPORT_CPU_LOCKABLE = 0x20000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x40000, + D3D10_FORMAT_SUPPORT_DISPLAY = 0x80000, + D3D10_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT = 0x100000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET = 0x200000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_LOAD = 0x400000, + D3D10_FORMAT_SUPPORT_SHADER_GATHER = 0x800000, + D3D10_FORMAT_SUPPORT_BACK_BUFFER_CAST = 0x1000000, +}} +RIDL!{#[uuid(0x9b7e4c0d, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Asynchronous(ID3D10AsynchronousVtbl): ID3D10DeviceChild(ID3D10DeviceChildVtbl) { + fn Begin() -> (), + fn End() -> (), + fn GetData( + pData: *mut c_void, + DataSize: UINT, + GetDataFlags: UINT, + ) -> HRESULT, + fn GetDataSize() -> UINT, +}} +ENUM!{enum D3D10_ASYNC_GETDATA_FLAG { + D3D10_ASYNC_GETDATA_DONOTFLUSH = 0x1, +}} +ENUM!{enum D3D10_QUERY { + D3D10_QUERY_EVENT = 0, + D3D10_QUERY_OCCLUSION = D3D10_QUERY_EVENT + 1, + D3D10_QUERY_TIMESTAMP = D3D10_QUERY_OCCLUSION + 1, + D3D10_QUERY_TIMESTAMP_DISJOINT = D3D10_QUERY_TIMESTAMP + 1, + D3D10_QUERY_PIPELINE_STATISTICS = D3D10_QUERY_TIMESTAMP_DISJOINT + 1, + D3D10_QUERY_OCCLUSION_PREDICATE = D3D10_QUERY_PIPELINE_STATISTICS + 1, + D3D10_QUERY_SO_STATISTICS = D3D10_QUERY_OCCLUSION_PREDICATE + 1, + D3D10_QUERY_SO_OVERFLOW_PREDICATE = D3D10_QUERY_SO_STATISTICS + 1, +}} +ENUM!{enum D3D10_QUERY_MISC_FLAG { + D3D10_QUERY_MISC_PREDICATEHINT = 0x1, +}} +STRUCT!{struct D3D10_QUERY_DESC { + Query: D3D10_QUERY, + MiscFlags: UINT, +}} +RIDL!{#[uuid(0x9b7e4c0e, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Query(ID3D10QueryVtbl): ID3D10Asynchronous(ID3D10AsynchronousVtbl) { + fn GetDesc( + pDesc: *mut D3D10_QUERY_DESC, + ) -> (), +}} +RIDL!{#[uuid(0x9b7e4c10, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Predicate(ID3D10PredicateVtbl): ID3D10Query(ID3D10QueryVtbl) {}} +STRUCT!{struct D3D10_QUERY_DATA_TIMESTAMP_DISJOINT { + Frequency: UINT64, + Disjoint: BOOL, +}} +STRUCT!{struct D3D10_QUERY_DATA_PIPELINE_STATISTICS { + IAVertices: UINT64, + IAPrimitives: UINT64, + VSInvocations: UINT64, + GSInvocations: UINT64, + GSPrimitives: UINT64, + CInvocations: UINT64, + CPrimitives: UINT64, + PSInvocations: UINT64, +}} +STRUCT!{struct D3D10_QUERY_DATA_SO_STATISTICS { + NumPrimitivesWritten: UINT64, + PrimitivesStorageNeeded: UINT64, +}} +ENUM!{enum D3D10_COUNTER { + D3D10_COUNTER_GPU_IDLE, + D3D10_COUNTER_VERTEX_PROCESSING, + D3D10_COUNTER_GEOMETRY_PROCESSING, + D3D10_COUNTER_PIXEL_PROCESSING, + D3D10_COUNTER_OTHER_GPU_PROCESSING, + D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION, + D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION, + D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION, + D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION, + D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION, + D3D10_COUNTER_VS_MEMORY_LIMITED, + D3D10_COUNTER_VS_COMPUTATION_LIMITED, + D3D10_COUNTER_GS_MEMORY_LIMITED, + D3D10_COUNTER_GS_COMPUTATION_LIMITED, + D3D10_COUNTER_PS_MEMORY_LIMITED, + D3D10_COUNTER_PS_COMPUTATION_LIMITED, + D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE, + D3D10_COUNTER_TEXTURE_CACHE_HIT_RATE, + D3D10_COUNTER_DEVICE_DEPENDENT_0, +}} +ENUM!{enum D3D10_COUNTER_TYPE { + D3D10_COUNTER_TYPE_FLOAT32 = 0, + D3D10_COUNTER_TYPE_UINT16 = D3D10_COUNTER_TYPE_FLOAT32 + 1, + D3D10_COUNTER_TYPE_UINT32 = D3D10_COUNTER_TYPE_UINT16 + 1, + D3D10_COUNTER_TYPE_UINT64 = D3D10_COUNTER_TYPE_UINT32 + 1, +}} +STRUCT!{struct D3D10_COUNTER_DESC { + Counter: D3D10_COUNTER, + MiscFlags: UINT, +}} +STRUCT!{struct D3D10_COUNTER_INFO { + LastDeviceDependentCounter: D3D10_COUNTER, + NumSimultaneousCounters: UINT, + NumDetectableParallelUnits: UINT8, +}} +RIDL!{#[uuid(0x9b7e4c11, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Counter(ID3D10CounterVtbl): ID3D10Asynchronous(ID3D10AsynchronousVtbl) { + fn GetDesc( + pDesc: *mut D3D10_COUNTER_DESC, + ) -> (), +}} +RIDL!{#[uuid(0x9b7e4c0f, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Device(ID3D10DeviceVtbl): IUnknown(IUnknownVtbl) { + fn VSSetConstantBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppConstantBuffers: *const *mut ID3D10Buffer, + ) -> (), + fn PSSetShaderResources( + StartSlot: UINT, + NumViews: UINT, + ppShaderResourceViews: *const *mut ID3D10ShaderResourceView, + ) -> (), + fn PSSetShader( + pPixelShader: *mut ID3D10PixelShader, + ) -> (), + fn PSSetSamplers( + StartSlot: UINT, + NumSamplers: UINT, + ppSamplers: *const *mut ID3D10SamplerState, + ) -> (), + fn VSSetShader( + pVertexShader: *mut ID3D10VertexShader, + ) -> (), + fn DrawIndexed( + IndexCount: UINT, + StartIndexLocation: UINT, + BaseVertexLocation: INT, + ) -> (), + fn Draw( + VertexCount: UINT, + StartVertexLocation: UINT, + ) -> (), + fn PSSetConstantBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppConstantBuffers: *const *mut ID3D10Buffer, + ) -> (), + fn IASetInputLayout( + pInputLayout: *mut ID3D10InputLayout, + ) -> (), + fn IASetVertexBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppVertexBuffers: *const *mut ID3D10Buffer, + pStrides: *const UINT, + pOffsets: *const UINT, + ) -> (), + fn IASetIndexBuffer( + pIndexBuffer: *mut ID3D10Buffer, + Format: DXGI_FORMAT, + Offset: UINT, + ) -> (), + fn DrawIndexedInstanced( + IndexCountPerInstance: UINT, + InstanceCount: UINT, + StartIndexLocation: UINT, + BaseVertexLocation: INT, + StartInstanceLocation: UINT, + ) -> (), + fn DrawInstanced( + VertexCountPerInstance: UINT, + InstanceCount: UINT, + StartVertexLocation: UINT, + StartInstanceLocation: UINT, + ) -> (), + fn GSSetConstantBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppConstantBuffers: *const *mut ID3D10Buffer, + ) -> (), + fn GSSetShader( + pShader: *mut ID3D10GeometryShader, + ) -> (), + fn IASetPrimitiveTopology( + Topology: D3D10_PRIMITIVE_TOPOLOGY, + ) -> (), + fn VSSetShaderResources( + StartSlot: UINT, + NumViews: UINT, + ppShaderResourceViews: *const *mut ID3D10ShaderResourceView, + ) -> (), + fn VSSetSamplers( + StartSlot: UINT, + NumSamplers: UINT, + ppSamplers: *const *mut ID3D10SamplerState, + ) -> (), + fn SetPredication( + pPredicate: *mut ID3D10Predicate, + PredicateValue: BOOL, + ) -> (), + fn GSSetShaderResources( + StartSlot: UINT, + NumViews: UINT, + ppShaderResourceViews: *const *mut ID3D10ShaderResourceView, + ) -> (), + fn GSSetSamplers( + StartSlot: UINT, + NumSamplers: UINT, + ppSamplers: *const *mut ID3D10SamplerState, + ) -> (), + fn OMSetRenderTargets( + NumViews: UINT, + ppRenderTargetViews: *const *mut ID3D10RenderTargetView, + pDepthStencilView: *mut ID3D10DepthStencilView, + ) -> (), + fn OMSetBlendState( + pBlendState: *mut ID3D10BlendState, + BlendFactor: &[FLOAT; 4], + SampleMask: UINT, + ) -> (), + fn OMSetDepthStencilState( + pDepthStencilState: *mut ID3D10DepthStencilState, + StencilRef: UINT, + ) -> (), + fn SOSetTargets( + NumBuffers: UINT, + ppSOTargets: *const *mut ID3D10Buffer, + pOffsets: *const UINT, + ) -> (), + fn DrawAuto() -> (), + fn RSSetState( + pRasterizerState: *mut ID3D10RasterizerState, + ) -> (), + fn RSSetViewports( + NumViewports: UINT, + pViewports: *const D3D10_VIEWPORT, + ) -> (), + fn RSSetScissorRects( + NumRects: UINT, + pRects: *const D3D10_RECT, + ) -> (), + fn CopySubresourceRegion( + pDstResource: *mut ID3D10Resource, + DstSubresource: UINT, + DstX: UINT, + DstY: UINT, + DstZ: UINT, + pSrcResource: *mut ID3D10Resource, + SrcSubresource: UINT, + pSrcBox: *const D3D10_BOX, + ) -> (), + fn CopyResource( + pDstResource: *mut ID3D10Resource, + pSrcResource: *mut ID3D10Resource, + ) -> (), + fn UpdateSubresource( + pDstResource: *mut ID3D10Resource, + DstSubresource: UINT, + pDstBox: *const D3D10_BOX, + pSrcData: *const c_void, + SrcRowPitch: UINT, + SrcDepthPitch: UINT, + ) -> (), + fn ClearRenderTargetView( + pRenderTargetView: *mut ID3D10RenderTargetView, + ColorRGBA: &[FLOAT; 4], + ) -> (), + fn ClearDepthStencilView( + pDepthStencilView: *mut ID3D10DepthStencilView, + ClearFlags: UINT, + Depth: FLOAT, + Stencil: UINT8, + ) -> (), + fn GenerateMips( + pShaderResourceView: *mut ID3D10ShaderResourceView, + ) -> (), + fn ResolveSubresource( + pDstResource: *mut ID3D10Resource, + DstSubresource: UINT, + pSrcResource: *mut ID3D10Resource, + SrcSubresource: UINT, + Format: DXGI_FORMAT, + ) -> (), + fn VSGetConstantBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppConstantBuffers: *mut *mut ID3D10Buffer, + ) -> (), + fn PSGetShaderResources( + StartSlot: UINT, + NumViews: UINT, + ppShaderResourceViews: *mut *mut ID3D10ShaderResourceView, + ) -> (), + fn PSGetShader( + ppPixelShader: *mut *mut ID3D10PixelShader, + ) -> (), + fn PSGetSamplers( + StartSlot: UINT, + NumSamplers: UINT, + ppSamplers: *mut *mut ID3D10SamplerState, + ) -> (), + fn VSGetShader( + ppVertexShader: *mut *mut ID3D10VertexShader, + ) -> (), + fn PSGetConstantBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppConstantBuffers: *mut *mut ID3D10Buffer, + ) -> (), + fn IAGetInputLayout( + ppInputLayout: *mut *mut ID3D10InputLayout, + ) -> (), + fn IAGetVertexBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppVertexBuffers: *mut *mut ID3D10Buffer, + pStrides: *mut UINT, + pOffsets: *mut UINT, + ) -> (), + fn IAGetIndexBuffer( + pIndexBuffer: *mut *mut ID3D10Buffer, + Format: *mut DXGI_FORMAT, + Offset: *mut UINT, + ) -> (), + fn GSGetConstantBuffers( + StartSlot: UINT, + NumBuffers: UINT, + ppConstantBuffers: *mut *mut ID3D10Buffer, + ) -> (), + fn GSGetShader( + ppGeometryShader: *mut *mut ID3D10GeometryShader, + ) -> (), + fn IAGetPrimitiveTopology( + pTopology: *mut D3D10_PRIMITIVE_TOPOLOGY, + ) -> (), + fn VSGetShaderResources( + StartSlot: UINT, + NumViews: UINT, + ppShaderResourceViews: *mut *mut ID3D10ShaderResourceView, + ) -> (), + fn VSGetSamplers( + StartSlot: UINT, + NumSamplers: UINT, + ppSamplers: *mut *mut ID3D10SamplerState, + ) -> (), + fn GetPredication( + ppPredicate: *mut *mut ID3D10Predicate, + pPredicateValue: *mut BOOL, + ) -> (), + fn GSGetShaderResources( + StartSlot: UINT, + NumViews: UINT, + ppShaderResourceViews: *mut *mut ID3D10ShaderResourceView, + ) -> (), + fn GSGetSamplers( + StartSlot: UINT, + NumSamplers: UINT, + ppSamplers: *mut *mut ID3D10SamplerState, + ) -> (), + fn OMGetRenderTargets( + NumViews: UINT, + ppRenderTargetViews: *mut *mut ID3D10RenderTargetView, + ppDepthStencilView: *mut *mut ID3D10DepthStencilView, + ) -> (), + fn OMGetBlendState( + ppBlendState: *mut *mut ID3D10BlendState, + BlendFactor: &mut [FLOAT; 4], + pSampleMask: *mut UINT, + ) -> (), + fn OMGetDepthStencilState( + ppDepthStencilState: *mut *mut ID3D10DepthStencilState, + pStencilRef: *mut UINT, + ) -> (), + fn SOGetTargets( + NumBuffers: UINT, + ppSOTargets: *mut *mut ID3D10Buffer, + ) -> (), + fn RSGetState( + ppRasterizerState: *mut *mut ID3D10RasterizerState, + ) -> (), + fn RSGetViewports( + pNumViewports: *mut UINT, + pViewports: *mut D3D10_VIEWPORT, + ) -> (), + fn RSGetScissorRects( + pNumRects: *mut UINT, + pRects: *mut D3D10_RECT, + ) -> (), + fn GetDeviceRemovedReason() -> HRESULT, + fn SetExceptionMode( + RaiseFlags: UINT, + ) -> HRESULT, + fn GetExceptionMode() -> UINT, + fn GetPrivateData( + guid: REFGUID, + pDataSize: *mut UINT, + pData: *mut c_void, + ) -> HRESULT, + fn SetPrivateData( + guid: REFGUID, + DataSize: UINT, + pData: *const c_void, + ) -> HRESULT, + fn SetPrivateDataInterface( + guid: REFGUID, + pData: *const IUnknown, + ) -> HRESULT, + fn ClearState() -> (), + fn Flush() -> (), + fn CreateBuffer( + pDesc: *const D3D10_BUFFER_DESC, + pInitialData: *const D3D10_SUBRESOURCE_DATA, + ppBuffer: *mut *mut ID3D10Buffer, + ) -> HRESULT, + fn CreateTexture1D( + pDesc: *const D3D10_TEXTURE1D_DESC, + pInitialData: *const D3D10_SUBRESOURCE_DATA, + ppTexture1D: *mut *mut ID3D10Texture1D, + ) -> HRESULT, + fn CreateTexture2D( + pDesc: *const D3D10_TEXTURE2D_DESC, + pInitialData: *const D3D10_SUBRESOURCE_DATA, + ppTexture2D: *mut *mut ID3D10Texture2D, + ) -> HRESULT, + fn CreateTexture3D( + pDesc: *const D3D10_TEXTURE3D_DESC, + pInitialData: *const D3D10_SUBRESOURCE_DATA, + ppTexture3D: *mut *mut ID3D10Texture3D, + ) -> HRESULT, + fn CreateShaderResourceView( + pResource: *mut ID3D10Resource, + pDesc: *const D3D10_SHADER_RESOURCE_VIEW_DESC, + ppSRView: *mut *mut ID3D10ShaderResourceView, + ) -> HRESULT, + fn CreateRenderTargetView( + pResource: *mut ID3D10Resource, + pDesc: *const D3D10_RENDER_TARGET_VIEW_DESC, + ppRTView: *mut *mut ID3D10RenderTargetView, + ) -> HRESULT, + fn CreateDepthStencilView( + pResource: *mut ID3D10Resource, + pDesc: *const D3D10_DEPTH_STENCIL_VIEW_DESC, + ppDepthStencilView: *mut *mut ID3D10DepthStencilView, + ) -> HRESULT, + fn CreateInputLayout( + pInputElementDescs: *const D3D10_INPUT_ELEMENT_DESC, + NumElements: UINT, + pShaderBytecodeWithInputSignature: *const c_void, + BytecodeLength: SIZE_T, + ppInputLayout: *mut *mut ID3D10InputLayout, + ) -> HRESULT, + fn CreateVertexShader( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppVertexShader: *mut *mut ID3D10VertexShader, + ) -> HRESULT, + fn CreateGeometryShader( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppGeometryShader: *mut *mut ID3D10GeometryShader, + ) -> HRESULT, + fn CreateGeometryShaderWithStreamOutput( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + pSODeclaration: *const D3D10_SO_DECLARATION_ENTRY, + NumEntries: UINT, + OutputStreamStride: UINT, + ppGeometryShader: *mut *mut ID3D10GeometryShader, + ) -> HRESULT, + fn CreatePixelShader( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppPixelShader: *mut *mut ID3D10PixelShader, + ) -> HRESULT, + fn CreateBlendState( + pBlendStateDesc: *const D3D10_BLEND_DESC, + ppBlendState: *mut *mut ID3D10BlendState, + ) -> HRESULT, + fn CreateDepthStencilState( + pDepthStencilDesc: *const D3D10_DEPTH_STENCIL_DESC, + ppDepthStencilState: *mut *mut ID3D10DepthStencilState, + ) -> HRESULT, + fn CreateRasterizerState( + pRasterizerDesc: *const D3D10_RASTERIZER_DESC, + ppRasterizerState: *mut *mut ID3D10RasterizerState, + ) -> HRESULT, + fn CreateSamplerState( + pSamplerDesc: *const D3D10_SAMPLER_DESC, + ppSamplerState: *mut *mut ID3D10SamplerState, + ) -> HRESULT, + fn CreateQuery( + pQueryDesc: *const D3D10_QUERY_DESC, + ppQuery: *mut *mut ID3D10Query, + ) -> HRESULT, + fn CreatePredicate( + pPredicateDesc: *const D3D10_QUERY_DESC, + ppPredicate: *mut *mut ID3D10Predicate, + ) -> HRESULT, + fn CreateCounter( + pCounterDesc: *const D3D10_COUNTER_DESC, + ppCounter: *mut *mut ID3D10Counter, + ) -> HRESULT, + fn CheckFormatSupport( + Format: DXGI_FORMAT, + pFormatSupport: *mut UINT, + ) -> HRESULT, + fn CheckMultisampleQualityLevels( + Format: DXGI_FORMAT, + SampleCount: UINT, + pNumQualityLevels: *mut UINT, + ) -> HRESULT, + fn CheckCounterInfo( + pCounterInfo: *mut D3D10_COUNTER_INFO, + ) -> (), + fn CheckCounter( + pDesc: *const D3D10_COUNTER_DESC, + pType: *mut D3D10_COUNTER_TYPE, + pActiveCounters: *mut UINT, + szName: LPSTR, + pNameLength: *mut UINT, + szUnits: LPSTR, + pUnitsLength: *mut UINT, + szDescription: LPSTR, + pDescriptionLength: *mut UINT, + ) -> HRESULT, + fn GetCreationFlags() -> UINT, + fn OpenSharedResource( + hResource: HANDLE, + ReturnedInterface: REFIID, + ppResource: *mut *mut c_void, + ) -> HRESULT, + fn SetTextFilterSize( + Width: UINT, + Height: UINT, + ) -> (), + fn GetTextFilterSize( + pWidth: *mut UINT, + pHeight: *mut UINT, + ) -> (), +}} +RIDL!{#[uuid(0x9b7e4e00, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Multithread(ID3D10MultithreadVtbl): IUnknown(IUnknownVtbl) { + fn Enter() -> (), + fn Leave() -> (), + fn SetMultithreadProtected( + bMTProtect: BOOL, + ) -> BOOL, + fn GetMultithreadProtected() -> BOOL, +}} +ENUM!{enum D3D10_CREATE_DEVICE_FLAG { + D3D10_CREATE_DEVICE_SINGLETHREADED = 0x1, + D3D10_CREATE_DEVICE_DEBUG = 0x2, + D3D10_CREATE_DEVICE_SWITCH_TO_REF = 0x4, + D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x8, + D3D10_CREATE_DEVICE_ALLOW_NULL_FROM_MAP = 0x10, + D3D10_CREATE_DEVICE_BGRA_SUPPORT = 0x20, + D3D10_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x80, + D3D10_CREATE_DEVICE_STRICT_VALIDATION = 0x200, + D3D10_CREATE_DEVICE_DEBUGGABLE = 0x400, +}} +pub const D3D10_SDK_VERSION: DWORD = 29; +#[inline] +pub fn D3D10CalcSubresource(MipSlice: UINT, ArraySlice: UINT, MipLevels: UINT) -> UINT { + MipSlice + ArraySlice * MipLevels +} DEFINE_GUID!{IID_ID3D10DeviceChild, 0x9b7e4c00, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0} DEFINE_GUID!{IID_ID3D10DepthStencilState, diff --git a/src/um/d3d10_1.rs b/src/um/d3d10_1.rs index 3765ce309..2a32afff6 100644 --- a/src/um/d3d10_1.rs +++ b/src/um/d3d10_1.rs @@ -3,6 +3,140 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. +use shared::basetsd::UINT8; +use shared::dxgi::{DXGI_SWAP_CHAIN_DESC, IDXGIAdapter, IDXGISwapChain}; +use shared::dxgiformat::DXGI_FORMAT; +use shared::minwindef::{BOOL, DWORD, FLOAT, HMODULE, UINT}; +use um::d3d10::{ + D3D10_BLEND, D3D10_BLEND_OP, D3D10_BUFFER_SRV, D3D10_TEX1D_ARRAY_SRV, D3D10_TEX1D_SRV, + D3D10_TEX2DMS_ARRAY_SRV, D3D10_TEX2DMS_SRV, D3D10_TEX2D_ARRAY_SRV, D3D10_TEX2D_SRV, + D3D10_TEX3D_SRV, D3D10_TEXCUBE_SRV, ID3D10BlendState, ID3D10BlendStateVtbl, ID3D10Device, + ID3D10DeviceVtbl, ID3D10Resource, ID3D10ShaderResourceView, ID3D10ShaderResourceViewVtbl +}; +use um::d3d10misc::D3D10_DRIVER_TYPE; +use um::d3dcommon::D3D_SRV_DIMENSION; +use um::winnt::HRESULT; +pub const D3D10_1_DEFAULT_SAMPLE_MASK: DWORD = 0xffffffff; +pub const D3D10_1_FLOAT16_FUSED_TOLERANCE_IN_ULP: FLOAT = 0.6; +pub const D3D10_1_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP: FLOAT = 0.6; +pub const D3D10_1_GS_INPUT_REGISTER_COUNT: DWORD = 32; +pub const D3D10_1_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT: DWORD = 32; +pub const D3D10_1_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS: DWORD = 128; +pub const D3D10_1_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT: DWORD = 32; +pub const D3D10_1_PS_OUTPUT_MASK_REGISTER_COMPONENTS: DWORD = 1; +pub const D3D10_1_PS_OUTPUT_MASK_REGISTER_COMPONENT_BIT_COUNT: DWORD = 32; +pub const D3D10_1_PS_OUTPUT_MASK_REGISTER_COUNT: DWORD = 1; +pub const D3D10_1_SHADER_MAJOR_VERSION: DWORD = 4; +pub const D3D10_1_SHADER_MINOR_VERSION: DWORD = 1; +pub const D3D10_1_SO_BUFFER_MAX_STRIDE_IN_BYTES: DWORD = 2048; +pub const D3D10_1_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES: DWORD = 256; +pub const D3D10_1_SO_BUFFER_SLOT_COUNT: DWORD = 4; +pub const D3D10_1_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER: DWORD = 1; +pub const D3D10_1_SO_SINGLE_BUFFER_COMPONENT_LIMIT: DWORD = 64; +pub const D3D10_1_STANDARD_VERTEX_ELEMENT_COUNT: DWORD = 32; +pub const D3D10_1_SUBPIXEL_FRACTIONAL_BIT_COUNT: DWORD = 8; +pub const D3D10_1_VS_INPUT_REGISTER_COUNT: DWORD = 32; +pub const D3D10_1_VS_OUTPUT_REGISTER_COUNT: DWORD = 32; +ENUM!{enum D3D10_FEATURE_LEVEL1 { + D3D10_FEATURE_LEVEL_10_0 = 0xa000, + D3D10_FEATURE_LEVEL_10_1 = 0xa100, + D3D10_FEATURE_LEVEL_9_1 = 0x9100, + D3D10_FEATURE_LEVEL_9_2 = 0x9200, + D3D10_FEATURE_LEVEL_9_3 = 0x9300, +}} +STRUCT!{struct D3D10_RENDER_TARGET_BLEND_DESC1 { + BlendEnable: BOOL, + SrcBlend: D3D10_BLEND, + DestBlend: D3D10_BLEND, + BlendOp: D3D10_BLEND_OP, + SrcBlendAlpha: D3D10_BLEND, + DestBlendAlpha: D3D10_BLEND, + BlendOpAlpha: D3D10_BLEND_OP, + RenderTargetWriteMask: UINT8, +}} +STRUCT!{struct D3D10_BLEND_DESC1 { + AlphaToCoverageEnable: BOOL, + IndependentBlendEnable: BOOL, + RenderTarget: [D3D10_RENDER_TARGET_BLEND_DESC1; 8], +}} +RIDL!{#[uuid(0x9b7e4e00, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10BlendState1(ID3D10BlendState1Vtbl): ID3D10BlendState(ID3D10BlendStateVtbl) { + fn GetDesc1( + pDesc: *mut D3D10_BLEND_DESC1, + ) -> (), +}} +STRUCT!{struct D3D10_TEXCUBE_ARRAY_SRV1 { + MostDetailedMip: UINT, + MipLevels: UINT, + First2DArrayFace: UINT, + NumCubes: UINT, +}} +pub type D3D10_SRV_DIMENSION1 = D3D_SRV_DIMENSION; +UNION!{union D3D10_SHADER_RESOURCE_VIEW_DESC1_u { + [u32; 4], + Buffer Buffer_mut: D3D10_BUFFER_SRV, + Texture1D Texture1D_mut: D3D10_TEX1D_SRV, + Texture1DArray Texture1DArray_mut: D3D10_TEX1D_ARRAY_SRV, + Texture2D Texture2D_mut: D3D10_TEX2D_SRV, + Texture2DArray Texture2DArray_mut: D3D10_TEX2D_ARRAY_SRV, + Texture2DMS Texture2DMS_mut: D3D10_TEX2DMS_SRV, + Texture2DMSArray Texture2DMSArray_mut: D3D10_TEX2DMS_ARRAY_SRV, + Texture3D Texture3D_mut: D3D10_TEX3D_SRV, + TextureCube TextureCube_mut: D3D10_TEXCUBE_SRV, + TextureCubeArray TextureCubeArray_mut: D3D10_TEXCUBE_ARRAY_SRV1, +}} +STRUCT!{struct D3D10_SHADER_RESOURCE_VIEW_DESC1 { + Format: DXGI_FORMAT, + ViewDimension: D3D10_SRV_DIMENSION1, + u: D3D10_SHADER_RESOURCE_VIEW_DESC1_u , +}} +RIDL!{#[uuid(0x9b7e4c87, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10ShaderResourceView1(ID3D10ShaderResourceView1Vtbl): + ID3D10ShaderResourceView(ID3D10ShaderResourceViewVtbl) { + fn GetDesc1( + pDesc: *mut D3D10_SHADER_RESOURCE_VIEW_DESC1, + ) -> (), +}} +ENUM!{enum D3D10_STANDARD_MULTISAMPLE_QUALITY_LEVELS { + D3D10_STANDARD_MULTISAMPLE_PATTERN = 0xffffffff, + D3D10_CENTER_MULTISAMPLE_PATTERN = 0xfffffffe, +}} +RIDL!{#[uuid(0x9b7e4c8f, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Device1(ID3D10Device1Vtbl): ID3D10Device(ID3D10DeviceVtbl) { + fn CreateShaderResourceView1( + pResource: *mut ID3D10Resource, + pDesc: *const D3D10_SHADER_RESOURCE_VIEW_DESC1, + ppSRView: *mut *mut ID3D10ShaderResourceView1, + ) -> HRESULT, + fn CreateBlendState1( + pBlendStateDesc: *const D3D10_BLEND_DESC1, + ppBlendState: *mut *mut ID3D10BlendState1, + ) -> HRESULT, + fn GetFeatureLevel() -> D3D10_FEATURE_LEVEL1, +}} +pub const D3D10_1_SDK_VERSION: DWORD = 0x20; +extern "system" { + pub fn D3D10CreateDevice1( + pAdapter: *mut IDXGIAdapter, + DriverType: D3D10_DRIVER_TYPE, + Software: HMODULE, + Flags: UINT, + HardwareLevel: D3D10_FEATURE_LEVEL1, + SDKVersion: UINT, + ppDevice: *mut *mut ID3D10Device, + ) -> HRESULT; + pub fn D3D10CreateDeviceAndSwapChain1( + pAdapter: *mut IDXGIAdapter, + DriverType: D3D10_DRIVER_TYPE, + Software: HMODULE, + Flags: UINT, + HardwareLevel: D3D10_FEATURE_LEVEL1, + SDKVersion: UINT, + pSwapChainDesc: *const DXGI_SWAP_CHAIN_DESC, + ppSwapChain: *mut *mut IDXGISwapChain, + ppDevice: *mut *mut ID3D10Device, + ) -> HRESULT; +} DEFINE_GUID!{IID_ID3D10BlendState1, 0xedad8d99, 0x8a35, 0x4d6d, 0x85, 0x66, 0x2e, 0xa2, 0x76, 0xcd, 0xe1, 0x61} DEFINE_GUID!{IID_ID3D10ShaderResourceView1, diff --git a/src/um/d3d10_1shader.rs b/src/um/d3d10_1shader.rs index 69d9583ce..5f6c8b16f 100644 --- a/src/um/d3d10_1shader.rs +++ b/src/um/d3d10_1shader.rs @@ -3,5 +3,203 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. +use shared::minwindef::{BOOL, FLOAT, UINT}; +use um::d3d10::D3D10_PRIMITIVE; +use um::d3d10shader::{ + D3D10_SHADER_DESC, D3D10_SHADER_INPUT_BIND_DESC, D3D10_SHADER_VARIABLE_CLASS, + D3D10_SHADER_VARIABLE_TYPE, D3D10_SIGNATURE_PARAMETER_DESC, ID3D10ShaderReflection, + ID3D10ShaderReflectionConstantBuffer, ID3D10ShaderReflectionVariable, + ID3D10ShaderReflectionVtbl +}; +use um::winnt::{INT, LPCSTR}; +ENUM!{enum D3D10_SHADER_DEBUG_REGTYPE { + D3D10_SHADER_DEBUG_REG_INPUT, + D3D10_SHADER_DEBUG_REG_OUTPUT, + D3D10_SHADER_DEBUG_REG_CBUFFER, + D3D10_SHADER_DEBUG_REG_TBUFFER, + D3D10_SHADER_DEBUG_REG_TEMP, + D3D10_SHADER_DEBUG_REG_TEMPARRAY, + D3D10_SHADER_DEBUG_REG_TEXTURE, + D3D10_SHADER_DEBUG_REG_SAMPLER, + D3D10_SHADER_DEBUG_REG_IMMEDIATECBUFFER, + D3D10_SHADER_DEBUG_REG_LITERAL, + D3D10_SHADER_DEBUG_REG_UNUSED, + D3D11_SHADER_DEBUG_REG_INTERFACE_POINTERS, + D3D11_SHADER_DEBUG_REG_UAV, + D3D10_SHADER_DEBUG_REG_FORCE_DWORD = 0x7fffffff, +}} +ENUM!{enum D3D10_SHADER_DEBUG_SCOPETYPE { + D3D10_SHADER_DEBUG_SCOPE_GLOBAL, + D3D10_SHADER_DEBUG_SCOPE_BLOCK, + D3D10_SHADER_DEBUG_SCOPE_FORLOOP, + D3D10_SHADER_DEBUG_SCOPE_STRUCT, + D3D10_SHADER_DEBUG_SCOPE_FUNC_PARAMS, + D3D10_SHADER_DEBUG_SCOPE_STATEBLOCK, + D3D10_SHADER_DEBUG_SCOPE_NAMESPACE, + D3D10_SHADER_DEBUG_SCOPE_ANNOTATION, + D3D10_SHADER_DEBUG_SCOPE_FORCE_DWORD = 0x7fffffff, +}} +ENUM!{enum D3D10_SHADER_DEBUG_VARTYPE { + D3D10_SHADER_DEBUG_VAR_VARIABLE, + D3D10_SHADER_DEBUG_VAR_FUNCTION, + D3D10_SHADER_DEBUG_VAR_FORCE_DWORD = 0x7fffffff, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_TOKEN_INFO { + File: UINT, + Line: UINT, + Column: UINT, + TokenLength: UINT, + TokenId: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_VAR_INFO { + TokenId: UINT, + Type: D3D10_SHADER_VARIABLE_TYPE, + Register: UINT, + Component: UINT, + ScopeVar: UINT, + ScopeVarOffset: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_INPUT_INFO { + Var: UINT, + InitialRegisterSet: D3D10_SHADER_DEBUG_REGTYPE, + InitialBank: UINT, + InitialRegister: UINT, + InitialComponent: UINT, + InitialValue: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_SCOPEVAR_INFO { + TokenId: UINT, + VarType: D3D10_SHADER_DEBUG_VARTYPE, + Class: D3D10_SHADER_VARIABLE_CLASS, + Rows: UINT, + Columns: UINT, + StructMemberScope: UINT, + uArrayIndices: UINT, + ArrayElements: UINT, + ArrayStrides: UINT, + uVariables: UINT, + uFirstVariable: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_SCOPE_INFO { + ScopeType: D3D10_SHADER_DEBUG_SCOPETYPE, + Name: UINT, + uNameLen: UINT, + uVariables: UINT, + VariableData: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_OUTPUTVAR { + Var: UINT, + uValueMin: UINT, + uValueMax: UINT, + iValueMin: INT, + iValueMax: INT, + fValueMin: FLOAT, + fValueMax: FLOAT, + bNaNPossible: BOOL, + bInfPossible: BOOL, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_OUTPUTREG_INFO { + OutputRegisterSet: D3D10_SHADER_DEBUG_REGTYPE, + OutputReg: UINT, + TempArrayReg: UINT, + OutputComponents: [UINT; 4], + OutputVars: [D3D10_SHADER_DEBUG_OUTPUTVAR; 4], + IndexReg: UINT, + IndexComp: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_INST_INFO { + Id: UINT, + Opcode: UINT, + uOutputs: UINT, + pOutputs: [D3D10_SHADER_DEBUG_OUTPUTREG_INFO; 2], + TokenId: UINT, + NestingLevel: UINT, + Scopes: UINT, + ScopeInfo: UINT, + AccessedVars: UINT, + AccessedVarsInfo: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_FILE_INFO { + FileName: UINT, + FileNameLen: UINT, + FileData: UINT, + FileLen: UINT, +}} +STRUCT!{struct D3D10_SHADER_DEBUG_INFO { + Size: UINT, + Creator: UINT, + EntrypointName: UINT, + ShaderTarget: UINT, + CompileFlags: UINT, + Files: UINT, + FileInfo: UINT, + Instructions: UINT, + InstructionInfo: UINT, + Variables: UINT, + VariableInfo: UINT, + InputVariables: UINT, + InputVariableInfo: UINT, + Tokens: UINT, + TokenInfo: UINT, + Scopes: UINT, + ScopeInfo: UINT, + ScopeVariables: UINT, + ScopeVariableInfo: UINT, + UintOffset: UINT, + StringOffset: UINT, +}} +RIDL!{#[uuid(0xc3457783, 0xa846, 0x47ce, 0x95, 0x20, 0xce, 0xa6, 0xf6, 0x6e, 0x74, 0x47)] +interface ID3D10ShaderReflection1(ID3D10ShaderReflection1Vtbl): + ID3D10ShaderReflection(ID3D10ShaderReflectionVtbl) { + fn GetDesc( + pDesc: *mut D3D10_SHADER_DESC, + ) -> (), + fn GetConstantBufferByIndex( + Index: UINT, + ) -> *mut ID3D10ShaderReflectionConstantBuffer, + fn GetConstantBufferByName ( + Name: LPCSTR, + ) -> *mut ID3D10ShaderReflectionConstantBuffer, + fn GetResourceBindingDesc( + ResourceIndex: UINT, + pDesc: *mut D3D10_SHADER_INPUT_BIND_DESC, + ) -> (), + fn GetInputParameterDesc( + ParameterIndex: UINT, + pDesc: *mut D3D10_SIGNATURE_PARAMETER_DESC, + ) -> (), + fn GetOutputParameterDesc( + ParameterIndex: UINT, + pDesc: *mut D3D10_SIGNATURE_PARAMETER_DESC, + ) -> (), + fn GetVariableByName( + Name: LPCSTR, + ) -> *mut ID3D10ShaderReflectionVariable, + fn GetResourceBindingDescByName( + Name: LPCSTR, + pDesc: *mut D3D10_SHADER_INPUT_BIND_DESC, + ) -> (), + fn GetMovInstructionCount( + Count: *mut UINT, + ) -> (), + fn GetMovcInstructionCount( + Count: *mut UINT, + ) -> (), + fn GetConversionInstructionCount( + Count: *mut UINT, + ) -> (), + fn GetBitwiseInstructionCount( + Count: *mut UINT, + ) -> (), + fn GetGSInputPrimitive( + pPrim: *mut D3D10_PRIMITIVE, + ) -> (), + fn IsLevel9Shader( + pbLevel9Shader: *mut BOOL, + ) -> (), + fn IsSampleFrequencyShader( + pbSampleFrequency: *mut BOOL, + ) -> (), +}} DEFINE_GUID!{IID_ID3D10ShaderReflection1, 0xc3457783, 0xa846, 0x47ce, 0x95, 0x20, 0xce, 0xa6, 0xf6, 0x6e, 0x74, 0x47} diff --git a/src/um/d3d10effect.rs b/src/um/d3d10effect.rs index de93acec4..193c37a7b 100644 --- a/src/um/d3d10effect.rs +++ b/src/um/d3d10effect.rs @@ -3,6 +3,1202 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. +use ctypes::c_void; +use shared::basetsd::SIZE_T; +use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, UINT}; +use um::d3d10::{ + D3D10_BLEND_DESC, D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT, + D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT, + D3D10_DEPTH_STENCIL_DESC, D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT, D3D10_RASTERIZER_DESC, + D3D10_SAMPLER_DESC, ID3D10BlendState, ID3D10Buffer, ID3D10DepthStencilState, + ID3D10DepthStencilView, ID3D10Device, ID3D10GeometryShader, ID3D10PixelShader, + ID3D10RasterizerState, ID3D10RenderTargetView, ID3D10SamplerState, ID3D10ShaderResourceView, + ID3D10VertexShader +}; +use um::d3d10shader::{ + D3D10_SHADER_MACRO, D3D10_SHADER_VARIABLE_CLASS, D3D10_SHADER_VARIABLE_TYPE, + D3D10_SIGNATURE_PARAMETER_DESC, ID3D10Include +}; +use um::d3dcommon::ID3D10Blob; +use um::unknwnbase::{IUnknown, IUnknownVtbl}; +use um::winnt::{HRESULT, INT, LPCSTR}; +ENUM!{enum D3D10_DEVICE_STATE_TYPES { + D3D10_DST_SO_BUFFERS=1, + D3D10_DST_OM_RENDER_TARGETS, + D3D10_DST_OM_DEPTH_STENCIL_STATE, + D3D10_DST_OM_BLEND_STATE, + D3D10_DST_VS, + D3D10_DST_VS_SAMPLERS, + D3D10_DST_VS_SHADER_RESOURCES, + D3D10_DST_VS_CONSTANT_BUFFERS, + D3D10_DST_GS, + D3D10_DST_GS_SAMPLERS, + D3D10_DST_GS_SHADER_RESOURCES, + D3D10_DST_GS_CONSTANT_BUFFERS, + D3D10_DST_PS, + D3D10_DST_PS_SAMPLERS, + D3D10_DST_PS_SHADER_RESOURCES, + D3D10_DST_PS_CONSTANT_BUFFERS, + D3D10_DST_IA_VERTEX_BUFFERS, + D3D10_DST_IA_INDEX_BUFFER, + D3D10_DST_IA_INPUT_LAYOUT, + D3D10_DST_IA_PRIMITIVE_TOPOLOGY, + D3D10_DST_RS_VIEWPORTS, + D3D10_DST_RS_SCISSOR_RECTS, + D3D10_DST_RS_RASTERIZER_STATE, + D3D10_DST_PREDICATION, +}} +STRUCT!{struct D3D10_STATE_BLOCK_MASK { + VS: BYTE, + VSSamplers: [BYTE; (D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT as usize+7)/8], + VSShaderResources: [BYTE; (D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT as usize+7)/8], + VSConstantBuffers: [BYTE; (D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT as usize+7)/8], + GS: BYTE, + GSSamplers: [BYTE; (D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT as usize+7)/8], + GSShaderResources: [BYTE; (D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT as usize+7)/8], + GSConstantBuffers: [BYTE; (D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT as usize+7)/8], + PS: BYTE, + PSSamplers: [BYTE; (D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT as usize+7)/8], + PSShaderResources: [BYTE; (D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT as usize+7)/8], + PSConstantBuffers: [BYTE; (D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT as usize+7)/8], + IAVertexBuffers: [BYTE; (D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT as usize+7)/8], + IAIndexBuffer: BYTE, + IAInputLayout: BYTE, + IAPrimitiveTopology: BYTE, + OMRenderTargets: BYTE, + OMDepthStencilState: BYTE, + OMBlendState: BYTE, + RSViewports: BYTE, + RSScissorRects: BYTE, + RSRasterizerState: BYTE, + SOBuffers: BYTE, + Predication: BYTE, +}} +RIDL!{#[uuid(0x0803425a, 0x57f5, 0x4dd6, 0x94, 0x65, 0xa8, 0x75, 0x70, 0x83, 0x4a, 0x08)] +interface ID3D10StateBlock(ID3D10StateBlockVtbl): IUnknown(IUnknownVtbl) { + fn Capture() -> (), + fn Apply() -> (), + fn ReleaseAllDeviceObjects() -> (), + fn GetDevice( + ppDevice: *mut *mut ID3D10Device, + ) -> (), +}} +extern "system" { + pub fn D3D10StateBlockMaskUnion( + pA: *mut D3D10_STATE_BLOCK_MASK, + pB: *mut D3D10_STATE_BLOCK_MASK, + pResult: *mut D3D10_STATE_BLOCK_MASK, + ) -> HRESULT; + pub fn D3D10StateBlockMaskIntersect( + pA: *mut D3D10_STATE_BLOCK_MASK, + pB: *mut D3D10_STATE_BLOCK_MASK, + pResult: *mut D3D10_STATE_BLOCK_MASK, + ) -> HRESULT; + pub fn D3D10StateBlockMaskDifference( + pA: *mut D3D10_STATE_BLOCK_MASK, + pB: *mut D3D10_STATE_BLOCK_MASK, + pResult: *mut D3D10_STATE_BLOCK_MASK, + ) -> HRESULT; + pub fn D3D10StateBlockMaskEnableCapture( + pMask: *mut D3D10_STATE_BLOCK_MASK, + StateType: D3D10_DEVICE_STATE_TYPES, + RangeStart: UINT, + RangeLength: UINT, + ) -> HRESULT; + pub fn D3D10StateBlockMaskDisableCapture( + pMask: *mut D3D10_STATE_BLOCK_MASK, + StateType: D3D10_DEVICE_STATE_TYPES, + RangeStart: UINT, + RangeLength: UINT, + ) -> HRESULT; + pub fn D3D10StateBlockMaskEnableAll( + pMask: *mut D3D10_STATE_BLOCK_MASK, + ) -> HRESULT; + pub fn D3D10StateBlockMaskDisableAll( + pMask: *mut D3D10_STATE_BLOCK_MASK, + ) -> HRESULT; + pub fn D3D10StateBlockMaskGetSetting( + pMask: *mut D3D10_STATE_BLOCK_MASK, + StateType: D3D10_DEVICE_STATE_TYPES, + Entry: UINT, + ) -> HRESULT; + pub fn D3D10CreateStateBlock( + pDevice: *mut ID3D10Device, + pStateBlockMask: *mut D3D10_STATE_BLOCK_MASK, + ppStateBlock: *mut *mut ID3D10StateBlock, + ) -> HRESULT; +} +pub const D3D10_EFFECT_COMPILE_CHILD_EFFECT: DWORD = 1 << 0; +pub const D3D10_EFFECT_COMPILE_ALLOW_SLOW_OPS: DWORD = 1 << 1; +pub const D3D10_EFFECT_SINGLE_THREADED: DWORD = 1 << 3; +pub const D3D10_EFFECT_VARIABLE_POOLED: DWORD = 1 << 0; +pub const D3D10_EFFECT_VARIABLE_ANNOTATION: DWORD = 1 << 1; +pub const D3D10_EFFECT_VARIABLE_EXPLICIT_BIND_POINT: DWORD = 1 << 2; +STRUCT!{struct D3D10_EFFECT_TYPE_DESC { + TypeName: LPCSTR, + Class: D3D10_SHADER_VARIABLE_CLASS, + Type: D3D10_SHADER_VARIABLE_TYPE, + Elements: UINT, + Members: UINT, + Rows: UINT, + Columns: UINT, + PackedSize: UINT, + UnpackedSize: UINT, + Stride: UINT, +}} +RIDL!{#[uuid(0x4e9e1ddc, 0xcd9d, 0x4772, 0xa8, 0x37, 0x00, 0x18, 0x0b, 0x9b, 0x88, 0xfd)] +interface ID3D10EffectType(ID3D10EffectTypeVtbl) { + fn IsValid() -> BOOL, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_TYPE_DESC, + ) -> (), + fn GetMemberTypeByIndex( + Index: UINT, + ) -> *mut ID3D10EffectType, + fn GetMemberTypeByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectType, + fn GetMemberTypeBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectType, + fn GetMemberName( + Index: UINT, + ) -> LPCSTR, + fn GetMemberSemantic( + Index: UINT, + ) -> LPCSTR, +}} +STRUCT!{struct D3D10_EFFECT_VARIABLE_DESC { + Name: LPCSTR, + Semantic: LPCSTR, + Flags: UINT, + Annotations: UINT, + BufferOffset: UINT, + ExplicitBindPoint: UINT, +}} +RIDL!{#[uuid(0xae897105, 0x00e6, 0x45bf, 0xbb, 0x8e, 0x28, 0x1d, 0xd6, 0xdb, 0x8e, 0x1b)] +interface ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn GetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x00e48f7b, 0xd2c8, 0x49e8, 0xa8, 0x6c, 0x02, 0x2d, 0xee, 0x53, 0x43, 0x1f)] +interface ID3D10EffectScalarVariable(ID3D10EffectScalarVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn GetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn SetFloat( + Value: FLOAT, + ) -> (), + fn GetFloat( + pValue: *mut FLOAT, + ) -> (), + fn SetFloatArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetFloatArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), + fn SetInt( + Value: INT, + ) -> (), + fn GetInt( + pValue: *mut INT, + ) -> (), + fn SetIntArray( + pData: *mut INT, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetIntArray( + pData: *mut INT, + Offset: UINT, + Count: UINT, + ) -> (), + fn SetBool( + Value: BOOL, + ) -> (), + fn GetBool( + pValue: *mut BOOL, + ) -> (), + fn SetBoolArray( + pData: *mut BOOL, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetBoolArray( + pData: *mut BOOL, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x00e48f7b, 0xd2c8, 0x49e8, 0xa8, 0x6c, 0x02, 0x2d, 0xee, 0x53, 0x43, 0x1f)] +interface ID3D10EffectVectorVariable(ID3D10EffectVectorVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn GetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn SetBoolVector( + pData: *mut BOOL, + ) -> (), + fn SetIntVector( + pData: *mut INT, + ) -> (), + fn SetFloatVector( + pData: *mut FLOAT, + ) -> (), + fn GetBoolVector( + pData: *mut BOOL, + ) -> (), + fn GetIntVector( + pData: *mut INT, + ) -> (), + fn GetFloatVector( + pData: *mut FLOAT, + ) -> (), + fn SetBoolVectorArray( + pData: *mut BOOL, + Offset: UINT, + Count: UINT, + ) -> (), + fn SetIntVectorArray( + pData: *mut INT, + Offset: UINT, + Count: UINT, + ) -> (), + fn SetFloatVectorArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetBoolVectorArray( + pData: *mut BOOL, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetIntVectorArray( + pData: *mut INT, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetFloatVectorArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x50666c24, 0xb82f, 0x4eed, 0xa1, 0x72, 0x5b, 0x6e, 0x7e, 0x85, 0x22, 0xe0)] +interface ID3D10EffectMatrixVariable(ID3D10EffectMatrixVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn GetRawValue( + pData: *mut c_void, + Offset: UINT, + ByteCount: UINT, + ) -> (), + fn SetMatrix( + pData: *mut FLOAT, + ) -> (), + fn GetMatrix( + pData: *mut FLOAT, + ) -> (), + fn SetMatrixArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetMatrixArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), + fn SetMatrixTranspose( + pData: *mut FLOAT, + ) -> (), + fn GetMatrixTranspose( + pData: *mut FLOAT, + ) -> (), + fn SetMatrixTransposeArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetMatrixTransposeArray( + pData: *mut FLOAT, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x71417501, 0x8df9, 0x4e0a, 0xa7, 0x8a, 0x25, 0x5f, 0x97, 0x56, 0xba, 0xff)] +interface ID3D10EffectStringVariable(ID3D10EffectStringVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn GetString( + ppString: *mut *mut LPCSTR, + ) -> (), + fn GetStringArray( + pData: *mut *mut LPCSTR, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0xc0a7157b, 0xd872, 0x4b1d, 0x80, 0x73, 0xef, 0xc2, 0xac, 0xd4, 0xb1, 0xfc)] +interface ID3D10EffectShaderResourceVariable(ID3D10EffectShaderResourceVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetResource( + pResource: *mut ID3D10ShaderResourceView, + ) -> (), + fn GetResource( + ppResource: *mut *mut ID3D10ShaderResourceView, + ) -> (), + fn SetResourceArray( + pResources: *mut ID3D10ShaderResourceView, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetResourceArray( + ppResources: *mut *mut ID3D10ShaderResourceView, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x28ca0cc3, 0xc2c9, 0x40bb, 0xb5, 0x7f, 0x67, 0xb7, 0x37, 0x12, 0x2b, 0x17)] +interface ID3D10EffectRenderTargetViewVariable(ID3D10EffectRenderTargetViewVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetRenderTarget( + pResource: *mut ID3D10RenderTargetView, + ) -> (), + fn GetRenderTarget( + ppResource: *mut *mut ID3D10RenderTargetView, + ) -> (), + fn SetRenderTargetArray( + pResources: *mut ID3D10RenderTargetView, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetRenderTargetArray( + ppResources: *mut *mut ID3D10RenderTargetView, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x3e02c918, 0xcc79, 0x4985, 0xb6, 0x22, 0x2d, 0x92, 0xad, 0x70, 0x16, 0x23)] +interface ID3D10EffectDepthStencilViewVariable(ID3D10EffectDepthStencilViewVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetDepthStencil( + pResource: *mut ID3D10DepthStencilView, + ) -> (), + fn GetDepthStencil( + ppResource: *mut *mut ID3D10DepthStencilView, + ) -> (), + fn SetDepthStencilArray( + pResources: *mut ID3D10DepthStencilView, + Offset: UINT, + Count: UINT, + ) -> (), + fn GetDepthStencilArray( + ppResources: *mut *mut ID3D10DepthStencilView, + Offset: UINT, + Count: UINT, + ) -> (), +}} +RIDL!{#[uuid(0x56648f4d, 0xcc8b, 0x4444, 0xa5, 0xad, 0xb5, 0xa3, 0xd7, 0x6e, 0x91, 0xb3)] +interface ID3D10EffectConstantBuffer(ID3D10EffectConstantBufferVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn SetConstantBuffer( + pConstantBuffer: *mut ID3D10Buffer, + ) -> (), + fn GetConstantBuffer( + ppConstantBuffer: *mut *mut ID3D10Buffer, + ) -> (), + fn SetTextureBuffer( + pTextureBuffer: *mut ID3D10ShaderResourceView, + ) -> (), + fn GetTextureBuffer( + ppTextureBuffer: *mut *mut ID3D10ShaderResourceView, + ) -> (), +}} +STRUCT!{struct D3D10_EFFECT_SHADER_DESC { + pInputSignature: *const BYTE, + IsInline: BOOL, + pBytecode: *const BYTE, + BytecodeLength: UINT, + SODecl: LPCSTR, + NumInputSignatureEntries: UINT, + NumOutputSignatureEntries: UINT, +}} +RIDL!{#[uuid(0x80849279, 0xc799, 0x4797, 0x8c, 0x33, 0x04, 0x07, 0xa0, 0x7d, 0x9e, 0x06)] +interface ID3D10EffectShaderVariable(ID3D10EffectShaderVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn GetShaderDesc( + ShaderIndex: UINT, + pDesc: *mut D3D10_EFFECT_SHADER_DESC, + ) -> (), + fn GetVertexShader( + ShaderIndex: UINT, + ppVS: *mut *mut ID3D10VertexShader, + ) -> (), + fn GetGeometryShader( + ShaderIndex: UINT, + ppGS: *mut *mut ID3D10GeometryShader, + ) -> (), + fn GetPixelShader( + ShaderIndex: UINT, + ppPS: *mut *mut ID3D10PixelShader, + ) -> (), + fn GetInputSignatureElementDesc( + ShaderIndex: UINT, + Element: UINT, + pDesc: *mut D3D10_SIGNATURE_PARAMETER_DESC, + ) -> (), + fn GetOutputSignatureElementDesc( + ShaderIndex: UINT, + Element: UINT, + pDesc: *mut D3D10_SIGNATURE_PARAMETER_DESC, + ) -> (), +}} +RIDL!{#[uuid(0x1fcd2294, 0xdf6d, 0x4eae, 0x86, 0xb3, 0x0e, 0x91, 0x60, 0xcf, 0xb0, 0x7b)] +interface ID3D10EffectBlendVariable(ID3D10EffectBlendVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn GetBlendState( + Index: UINT, + ppBlendState: *mut *mut ID3D10BlendState, + ) -> (), + fn GetBackingStore( + Index: UINT, + pBlendDesc: *mut D3D10_BLEND_DESC, + ) -> (), +}} +RIDL!{#[uuid(0xaf482368, 0x330a, 0x46a5, 0x9a, 0x5c, 0x01, 0xc7, 0x1a, 0xf2, 0x4c, 0x8d)] +interface ID3D10EffectDepthStencilVariable(ID3D10EffectDepthStencilVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn GetDepthStencilState( + Index: UINT, + ppDepthStencilState: *mut *mut ID3D10DepthStencilState, + ) -> (), + fn GetBackingStore( + Index: UINT, + pDepthStencilDesc: *mut D3D10_DEPTH_STENCIL_DESC, + ) -> (), +}} +RIDL!{#[uuid(0x21af9f0e, 0x4d94, 0x4ea9, 0x97, 0x85, 0x2c, 0xb7, 0x6b, 0x8c, 0x0b, 0x34)] +interface ID3D10EffectRasterizerVariable(ID3D10EffectRasterizerVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn GetRasterizerState( + Index: UINT, + ppRasterizerState: *mut *mut ID3D10RasterizerState, + ) -> (), + fn GetBackingStore( + Index: UINT, + pRasterizerDesc: *mut D3D10_RASTERIZER_DESC, + ) -> (), +}} +RIDL!{#[uuid(0x6530d5c7, 0x07e9, 0x4271, 0xa4, 0x18, 0xe7, 0xce, 0x4b, 0xd1, 0xe4, 0x80)] +interface ID3D10EffectSamplerVariable(ID3D10EffectSamplerVariableVtbl): + ID3D10EffectVariable(ID3D10EffectVariableVtbl) { + fn IsValid() -> BOOL, + fn GetType() -> *mut ID3D10EffectType, + fn GetDesc( + pDesc: *mut D3D10_EFFECT_VARIABLE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetMemberByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetMemberBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetElement( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetParentConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsScalar() -> *mut ID3D10EffectScalarVariable, + fn AsVector() -> *mut ID3D10EffectVectorVariable, + fn AsMatrix() -> *mut ID3D10EffectMatrixVariable, + fn AsString() -> *mut ID3D10EffectStringVariable, + fn AsShaderResource() -> *mut ID3D10EffectShaderResourceVariable, + fn AsRenderTargetView() -> *mut ID3D10EffectRenderTargetViewVariable, + fn AsDepthStencilView() -> *mut ID3D10EffectDepthStencilViewVariable, + fn AsConstantBuffer() -> *mut ID3D10EffectConstantBuffer, + fn AsShader() -> *mut ID3D10EffectShaderVariable, + fn AsBlend() -> *mut ID3D10EffectBlendVariable, + fn AsDepthStencil() -> *mut ID3D10EffectDepthStencilVariable, + fn AsRasterizer() -> *mut ID3D10EffectRasterizerVariable, + fn AsSampler() -> *mut ID3D10EffectSamplerVariable, + fn GetSampler( + Index: UINT, + ppSampler: *mut *mut ID3D10SamplerState, + ) -> (), + fn GetBackingStore( + Index: UINT, + pSamplerDesc: *mut D3D10_SAMPLER_DESC, + ) -> (), +}} +STRUCT!{struct D3D10_PASS_DESC { + Name: LPCSTR, + Annotations: UINT, + pIAInputSignature: *mut BYTE, + IAInputSignatureSize: SIZE_T, + StencilRef: UINT, + SampleMask: UINT, + BlendFactor: [FLOAT; 4], +}} +STRUCT!{struct D3D10_PASS_SHADER_DESC { + pShaderVariable: *mut ID3D10EffectShaderVariable, + ShaderIndex: UINT, +}} +RIDL!{#[uuid(0x5cfbeb89, 0x1a06, 0x46e0, 0xb2, 0x82, 0xe3, 0xf9, 0xbf, 0xa3, 0x6a, 0x54)] +interface ID3D10EffectPass(ID3D10EffectPassVtbl) { + fn IsValid() -> BOOL, + fn GetDesc( + pDesc: *mut D3D10_PASS_DESC, + ) -> (), + fn GetVertexShaderDesc( + pDesc: *mut D3D10_PASS_SHADER_DESC, + ) -> (), + fn GetGeometryShaderDesc( + pDesc: *mut D3D10_PASS_SHADER_DESC, + ) -> (), + fn GetPixelShaderDesc( + pDesc: *mut D3D10_PASS_SHADER_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn Apply( + Flags: UINT, + ) -> (), + fn ComputeStateBlockMask( + pStateBlockMask: *mut D3D10_STATE_BLOCK_MASK, + ) -> (), +}} +STRUCT!{struct D3D10_TECHNIQUE_DESC { + Name: LPCSTR, + Passes: UINT, + Annotations: UINT, +}} +RIDL!{#[uuid(0xdb122ce8, 0xd1c9, 0x4292, 0xb2, 0x37, 0x24, 0xed, 0x3d, 0xe8, 0xb1, 0x75)] +interface ID3D10EffectTechnique(ID3D10EffectTechniqueVtbl) { + fn IsValid() -> BOOL, + fn GetDesc( + pDesc: *mut D3D10_TECHNIQUE_DESC, + ) -> (), + fn GetAnnotationByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetAnnotationByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetPassByIndex( + Index: UINT, + ) -> *mut ID3D10EffectPass, + fn GetPassByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectPass, + fn ComputeStateBlockMask( + pStateBlockMask: *mut D3D10_STATE_BLOCK_MASK, + ) -> (), +}} +STRUCT!{struct D3D10_EFFECT_DESC { + IsChildEffect: BOOL, + ConstantBuffers: UINT, + SharedConstantBuffers: UINT, + GlobalVariables: UINT, + SharedGlobalVariables: UINT, + Techniques: UINT, +}} +RIDL!{#[uuid(0x51b0ca8b, 0xec0b, 0x4519, 0x87, 0x0d, 0x8e, 0xe1, 0xcb, 0x50, 0x17, 0xc7)] +interface ID3D10Effect(ID3D10EffectVtbl): IUnknown(IUnknownVtbl) { + fn IsValid() -> BOOL, + fn IsPool() -> BOOL, + fn GetDevice( + ppDevice: *mut *mut ID3D10Device, + ) -> (), + fn GetDesc( + pDesc: *mut D3D10_EFFECT_DESC, + ) -> (), + fn GetConstantBufferByIndex( + Index: UINT, + ) -> *mut ID3D10EffectConstantBuffer, + fn GetConstantBufferByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectConstantBuffer, + fn GetVariableByIndex( + Index: UINT, + ) -> *mut ID3D10EffectVariable, + fn GetVariableByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetVariableBySemantic( + Semantic: LPCSTR, + ) -> *mut ID3D10EffectVariable, + fn GetTechniqueByIndex( + Index: UINT, + ) -> *mut ID3D10EffectTechnique, + fn GetTechniqueByName( + Name: LPCSTR, + ) -> *mut ID3D10EffectTechnique, + fn Optimize() -> (), + fn IsOptimized() -> BOOL, +}} +RIDL!{#[uuid(0x9537ab04, 0x3250, 0x412e, 0x82, 0x13, 0xfc, 0xd2, 0xf8, 0x67, 0x79, 0x33)] +interface ID3D10EffectPool(ID3D10EffectPoolVtbl): IUnknown(IUnknownVtbl) { + fn AsEffect() -> *mut ID3D10Effect, +}} +extern "system" { + pub fn D3D10CompileEffectFromMemory( + pData: *mut c_void, + DataLength: SIZE_T, + pSrcFileName: LPCSTR, + pDefines: *const D3D10_SHADER_MACRO, + pInclude: *mut ID3D10Include, + HLSLFlags: UINT, + FXFlags: UINT, + ppCompiledEffect: *mut *mut ID3D10Blob, + ppErrors: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10CreateEffectFromMemory( + pData: *mut c_void, + DataLength: SIZE_T, + FXFlags: UINT, + pDevice: *mut ID3D10Device, + pEffectPool: *mut ID3D10EffectPool, + ppEffect: *mut *mut ID3D10Effect, + ) -> HRESULT; + pub fn D3D10CreateEffectPoolFromMemory( + pData: *mut c_void, + DataLength: SIZE_T, + FXFlags: UINT, + pDevice: *mut ID3D10Device, + pEffectPool: *mut *mut ID3D10EffectPool, + ) -> HRESULT; + pub fn D3D10DisassembleEffect( + pEffect: *mut ID3D10Effect , + EnableColorCode: BOOL, + ppDisassembly: *mut *mut ID3D10Blob , + ) -> HRESULT; +} DEFINE_GUID!{IID_ID3D10StateBlock, 0x0803425a, 0x57f5, 0x4dd6, 0x94, 0x65, 0xa8, 0x75, 0x70, 0x83, 0x4a, 0x08} DEFINE_GUID!{IID_ID3D10EffectType, diff --git a/src/um/d3d10misc.rs b/src/um/d3d10misc.rs index 5303f2eb3..bdd974924 100644 --- a/src/um/d3d10misc.rs +++ b/src/um/d3d10misc.rs @@ -3,5 +3,36 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. +use shared::dxgi::{DXGI_SWAP_CHAIN_DESC, IDXGIAdapter, IDXGISwapChain}; +use shared::minwindef::{HMODULE, UINT}; +use um::d3d10::ID3D10Device; +use um::winnt::HRESULT; +ENUM!{enum D3D10_DRIVER_TYPE { + D3D10_DRIVER_TYPE_HARDWARE = 0, + D3D10_DRIVER_TYPE_REFERENCE = 1, + D3D10_DRIVER_TYPE_NULL = 2, + D3D10_DRIVER_TYPE_SOFTWARE = 3, + D3D10_DRIVER_TYPE_WARP = 5, +}} +extern "system" { + pub fn D3D10CreateDevice( + pAdapter: *mut IDXGIAdapter, + DriverType: D3D10_DRIVER_TYPE, + Software: HMODULE, + Flags: UINT, + SDKVersion: UINT, + ppDevice: *mut *mut ID3D10Device, + ) -> HRESULT; + pub fn D3D10CreateDeviceAndSwapChain( + pAdapter: *mut IDXGIAdapter, + DriverType: D3D10_DRIVER_TYPE, + Software: HMODULE, + Flags: UINT, + SDKVersion: UINT, + pSwapChainDesc: *const DXGI_SWAP_CHAIN_DESC, + ppSwapChain: *mut *mut IDXGISwapChain, + ppDevice: *mut *mut ID3D10Device, + ) -> HRESULT; +} DEFINE_GUID!{GUID_DeviceType, 0xd722fb4d, 0x7a68, 0x437a, 0xb2, 0x0c, 0x58, 0x04, 0xee, 0x24, 0x94, 0xa6} diff --git a/src/um/d3d10sdklayers.rs b/src/um/d3d10sdklayers.rs index d71c483e4..bc08b2bfd 100644 --- a/src/um/d3d10sdklayers.rs +++ b/src/um/d3d10sdklayers.rs @@ -3,6 +3,672 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. +use shared::basetsd::{SIZE_T, UINT64}; +use shared::dxgi::IDXGISwapChain; +use shared::minwindef::{BOOL, DWORD, UINT}; +use um::unknwnbase::{IUnknown, IUnknownVtbl}; +use um::winnt::{HRESULT, LPCSTR}; +pub const D3D10_SDK_LAYERS_VERSION: DWORD = 11; +pub const D3D10_DEBUG_FEATURE_FLUSH_PER_RENDER_OP: DWORD = 0x1; +pub const D3D10_DEBUG_FEATURE_FINISH_PER_RENDER_OP: DWORD = 0x2; +pub const D3D10_DEBUG_FEATURE_PRESENT_PER_RENDER_OP: DWORD = 0x4; +RIDL!{#[uuid(0x9b7e4e01, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10Debug(ID3D10DebugVtbl): IUnknown(IUnknownVtbl) { + fn SetFeatureMask( + Mask: UINT, + ) -> HRESULT, + fn GetFeatureMask() -> UINT, + fn SetPresentPerRenderOpDelay( + Milliseconds: UINT, + ) -> HRESULT, + fn GetPresentPerRenderOpDelay() -> UINT, + fn SetSwapChain( + ppSwapChain: *mut IDXGISwapChain, + ) -> HRESULT, + fn GetSwapChain( + ppSwapChain: *mut *mut IDXGISwapChain, + ) -> HRESULT, + fn Validate() -> HRESULT, +}} +RIDL!{#[uuid(0x9b7e4e02, 0x342c, 0x4106, 0xa1, 0x9f, 0x4f, 0x27, 0x04, 0xf6, 0x89, 0xf0)] +interface ID3D10SwitchToRef(ID3D10SwitchToRefVtbl): IUnknown(IUnknownVtbl) { + fn SetUseRef( + UseRef: BOOL, + ) -> BOOL, + fn GetUseRef() -> BOOL, +}} +ENUM!{enum D3D10_MESSAGE_CATEGORY { + D3D10_MESSAGE_CATEGORY_APPLICATION_DEFINED = 0, + D3D10_MESSAGE_CATEGORY_MISCELLANEOUS, + D3D10_MESSAGE_CATEGORY_INITIALIZATION, + D3D10_MESSAGE_CATEGORY_CLEANUP, + D3D10_MESSAGE_CATEGORY_COMPILATION, + D3D10_MESSAGE_CATEGORY_STATE_CREATION, + D3D10_MESSAGE_CATEGORY_STATE_SETTING, + D3D10_MESSAGE_CATEGORY_STATE_GETTING, + D3D10_MESSAGE_CATEGORY_RESOURCE_MANIPULATION, + D3D10_MESSAGE_CATEGORY_EXECUTION, + D3D10_MESSAGE_CATEGORY_SHADER, +}} +ENUM!{enum D3D10_MESSAGE_SEVERITY { + D3D10_MESSAGE_SEVERITY_CORRUPTION = 0, + D3D10_MESSAGE_SEVERITY_ERROR, + D3D10_MESSAGE_SEVERITY_WARNING, + D3D10_MESSAGE_SEVERITY_INFO, + D3D10_MESSAGE_SEVERITY_MESSAGE, +}} +ENUM!{enum D3D10_MESSAGE_ID { + D3D10_MESSAGE_ID_UNKNOWN = 0, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_HAZARD, + D3D10_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_HAZARD, + D3D10_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_HAZARD, + D3D10_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_HAZARD, + D3D10_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_OMSETRENDERTARGETS_HAZARD, + D3D10_MESSAGE_ID_DEVICE_SOSETTARGETS_HAZARD, + D3D10_MESSAGE_ID_STRING_FROM_APPLICATION, + D3D10_MESSAGE_ID_CORRUPTED_THIS, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER1, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER2, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER3, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER4, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER5, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER6, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER7, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER8, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER9, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER10, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER11, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER12, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER13, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER14, + D3D10_MESSAGE_ID_CORRUPTED_PARAMETER15, + D3D10_MESSAGE_ID_CORRUPTED_MULTITHREADING, + D3D10_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY, + D3D10_MESSAGE_ID_IASETINPUTLAYOUT_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_IASETINDEXBUFFER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETSHADER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_VSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETSHADER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_SOSETTARGETS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETSHADER_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETSHADERRESOURCES_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETCONSTANTBUFFERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_PSSETSAMPLERS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_RSSETSTATE_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_OMSETBLENDSTATE_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_OMSETDEPTHSTENCILSTATE_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_SETPREDICATION_UNBINDDELETINGOBJECT, + D3D10_MESSAGE_ID_GETPRIVATEDATA_MOREDATA, + D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA, + D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN, + D3D10_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS, + D3D10_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS, + D3D10_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATEBUFFER_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEBUFFER_NULLDESC, + D3D10_MESSAGE_ID_CREATEBUFFER_INVALIDCONSTANTBUFFERBINDINGS, + D3D10_MESSAGE_ID_CREATEBUFFER_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE1D_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE1D_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE1D_NULLDESC, + D3D10_MESSAGE_ID_CREATETEXTURE1D_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE2D_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE2D_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE2D_NULLDESC, + D3D10_MESSAGE_ID_CREATETEXTURE2D_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDSAMPLES, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDUSAGE, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_UNRECOGNIZEDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDCPUACCESSFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDBINDFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDINITIALDATA, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDMIPLEVELS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATETEXTURE3D_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE3D_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATETEXTURE3D_NULLDESC, + D3D10_MESSAGE_ID_CREATETEXTURE3D_LARGEALLOCATION, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_NULLDESC, + D3D10_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE, + D3D10_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY, + D3D10_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE, + D3D10_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_TOOMANYOBJECTS, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDQUERY, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_INVALIDMISCFLAGS, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_UNEXPECTEDMISCFLAG, + D3D10_MESSAGE_ID_CREATEQUERYORPREDICATE_NULLDESC, + D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED, + D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED, + D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_OFFSET_TOO_LARGE, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_IASETINDEXBUFFER_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_FORMAT_INVALID, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_TOO_LARGE, + D3D10_MESSAGE_ID_DEVICE_IASETINDEXBUFFER_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_VSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_VSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_VSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSSETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_GSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_GSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSSETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_SOSETTARGETS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_SOSETTARGETS_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_PSSETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_PSSETCONSTANTBUFFERS_INVALIDBUFFER, + D3D10_MESSAGE_ID_DEVICE_PSSETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSSETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT, + D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR, + D3D10_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH, + D3D10_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH, + D3D10_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID, + D3D10_MESSAGE_ID_DEVICE_IAGETVERTEXBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_VSGETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GSGETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_SOGETTARGETS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSGETSHADERRESOURCES_VIEWS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSGETCONSTANTBUFFERS_BUFFERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_PSGETSAMPLERS_SAMPLERS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_RSGETVIEWPORTS_VIEWPORTS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_RSGETSCISSORRECTS_RECTS_EMPTY, + D3D10_MESSAGE_ID_DEVICE_GENERATEMIPS_RESOURCE_INVALID, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSUBRESOURCE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESUBRESOURCE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCEBOX, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDDESTINATIONSTATE, + D3D10_MESSAGE_ID_COPYSUBRESOURCEREGION_INVALIDSOURCESTATE, + D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE, + D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE, + D3D10_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE, + D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE, + D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX, + D3D10_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID, + D3D10_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID, + D3D10_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED, + D3D10_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE, + D3D10_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED, + D3D10_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED, + D3D10_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED, + D3D10_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS, + D3D10_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN, + D3D10_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE, + D3D10_MESSAGE_ID_REF_THREADING_MODE, + D3D10_MESSAGE_ID_REF_UMDRIVER_EXCEPTION, + D3D10_MESSAGE_ID_REF_KMDRIVER_EXCEPTION, + D3D10_MESSAGE_ID_REF_HARDWARE_EXCEPTION, + D3D10_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE, + D3D10_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER, + D3D10_MESSAGE_ID_REF_OUT_OF_MEMORY, + D3D10_MESSAGE_ID_REF_INFO, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE, + D3D10_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_INPUTLAYOUT_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_CONSTANT_BUFFER_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_SHADERRESOURCEVIEW_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_VIEW_DIMENSION_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_BUFFER_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_FORMAT_INVALID, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_BUFFER_TOO_SMALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_GS_INPUT_PRIMITIVE_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_RETURN_TYPE_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_POSITION_NOT_PRESENT, + D3D10_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_NOT_SET, + D3D10_MESSAGE_ID_DEVICE_DRAW_BOUND_RESOURCE_MAPPED, + D3D10_MESSAGE_ID_DEVICE_DRAW_INVALID_PRIMITIVETOPOLOGY, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_VERTEX_STRIDE_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_INDEX_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE, + D3D10_MESSAGE_ID_DEVICE_DRAW_SO_STRIDE_LARGER_THAN_BUFFER, + D3D10_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING, + D3D10_MESSAGE_ID_DEVICE_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0, + D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT, + D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT, + D3D10_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT, + D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN, + D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN, + D3D10_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC, + D3D10_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC, + D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW, + D3D10_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS, + D3D10_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH, + D3D10_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY, + D3D10_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY, + D3D10_MESSAGE_ID_CREATEQUERY_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATEPREDICATE_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATECOUNTER_OUTOFRANGE_COUNTER, + D3D10_MESSAGE_ID_CREATECOUNTER_SIMULTANEOUS_ACTIVE_COUNTERS_EXHAUSTED, + D3D10_MESSAGE_ID_CREATECOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER, + D3D10_MESSAGE_ID_CREATECOUNTER_OUTOFMEMORY_RETURN, + D3D10_MESSAGE_ID_CREATECOUNTER_NONEXCLUSIVE_RETURN, + D3D10_MESSAGE_ID_CREATECOUNTER_NULLDESC, + D3D10_MESSAGE_ID_CHECKCOUNTER_OUTOFRANGE_COUNTER, + D3D10_MESSAGE_ID_CHECKCOUNTER_UNSUPPORTED_WELLKNOWN_COUNTER, + D3D10_MESSAGE_ID_SETPREDICATION_INVALID_PREDICATE_STATE, + D3D10_MESSAGE_ID_QUERY_BEGIN_UNSUPPORTED, + D3D10_MESSAGE_ID_PREDICATE_BEGIN_DURING_PREDICATION, + D3D10_MESSAGE_ID_QUERY_BEGIN_DUPLICATE, + D3D10_MESSAGE_ID_QUERY_BEGIN_ABANDONING_PREVIOUS_RESULTS, + D3D10_MESSAGE_ID_PREDICATE_END_DURING_PREDICATION, + D3D10_MESSAGE_ID_QUERY_END_ABANDONING_PREVIOUS_RESULTS, + D3D10_MESSAGE_ID_QUERY_END_WITHOUT_BEGIN, + D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_DATASIZE, + D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_FLAGS, + D3D10_MESSAGE_ID_QUERY_GETDATA_INVALID_CALL, + D3D10_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE, + D3D10_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT, + D3D10_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH, + D3D10_MESSAGE_ID_LIVE_OBJECT_SUMMARY, + D3D10_MESSAGE_ID_LIVE_BUFFER, + D3D10_MESSAGE_ID_LIVE_TEXTURE1D, + D3D10_MESSAGE_ID_LIVE_TEXTURE2D, + D3D10_MESSAGE_ID_LIVE_TEXTURE3D, + D3D10_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW, + D3D10_MESSAGE_ID_LIVE_RENDERTARGETVIEW, + D3D10_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW, + D3D10_MESSAGE_ID_LIVE_VERTEXSHADER, + D3D10_MESSAGE_ID_LIVE_GEOMETRYSHADER, + D3D10_MESSAGE_ID_LIVE_PIXELSHADER, + D3D10_MESSAGE_ID_LIVE_INPUTLAYOUT, + D3D10_MESSAGE_ID_LIVE_SAMPLER, + D3D10_MESSAGE_ID_LIVE_BLENDSTATE, + D3D10_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE, + D3D10_MESSAGE_ID_LIVE_RASTERIZERSTATE, + D3D10_MESSAGE_ID_LIVE_QUERY, + D3D10_MESSAGE_ID_LIVE_PREDICATE, + D3D10_MESSAGE_ID_LIVE_COUNTER, + D3D10_MESSAGE_ID_LIVE_DEVICE, + D3D10_MESSAGE_ID_LIVE_SWAPCHAIN, + D3D10_MESSAGE_ID_D3D10_MESSAGES_END, + D3D10_MESSAGE_ID_D3D10L9_MESSAGES_START = 0x100000, + D3D10_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_STENCIL_NO_TWO_SIDED, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_DepthBiasClamp_NOT_SUPPORTED, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NO_COMPARISON_SUPPORT, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_EXCESSIVE_ANISOTROPY, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_OUT_OF_RANGE, + D3D10_MESSAGE_ID_VSSETSAMPLERS_NOT_SUPPORTED, + D3D10_MESSAGE_ID_VSSETSAMPLERS_TOO_MANY_SAMPLERS, + D3D10_MESSAGE_ID_PSSETSAMPLERS_TOO_MANY_SAMPLERS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_ARRAYS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_VB_AND_IB_BIND, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_TEXTURE_1D, + D3D10_MESSAGE_ID_CREATERESOURCE_DIMENSION_OUT_OF_RANGE, + D3D10_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_SHADER_RESOURCE, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_TOO_MANY_RENDER_TARGETS, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_NO_DIFFERING_BIT_DEPTHS, + D3D10_MESSAGE_ID_IASETVERTEXBUFFERS_BAD_BUFFER_INDEX, + D3D10_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_TOO_MANY_VIEWPORTS, + D3D10_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_ADJACENCY_UNSUPPORTED, + D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_TOO_MANY_SCISSORS, + D3D10_MESSAGE_ID_COPYRESOURCE_ONLY_TEXTURE_2D_WITHIN_GPU_MEMORY, + D3D10_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_3D_READBACK, + D3D10_MESSAGE_ID_COPYRESOURCE_NO_TEXTURE_ONLY_READBACK, + D3D10_MESSAGE_ID_CREATEINPUTLAYOUT_UNSUPPORTED_FORMAT, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_ALPHA_TO_COVERAGE, + D3D10_MESSAGE_ID_CREATERASTERIZERSTATE_DepthClipEnable_MUST_BE_TRUE, + D3D10_MESSAGE_ID_DRAWINDEXED_STARTINDEXLOCATION_MUST_BE_POSITIVE, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_MUST_USE_LOWEST_LOD, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_MINLOD_MUST_NOT_BE_FRACTIONAL, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_MAXLOD_MUST_BE_FLT_MAX, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_FIRSTARRAYSLICE_MUST_BE_ZERO, + D3D10_MESSAGE_ID_CREATESHADERRESOURCEVIEW_CUBES_MUST_HAVE_6_SIDES, + D3D10_MESSAGE_ID_CREATERESOURCE_NOT_BINDABLE_AS_RENDER_TARGET, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_DWORD_INDEX_BUFFER, + D3D10_MESSAGE_ID_CREATERESOURCE_MSAA_PRECLUDES_SHADER_RESOURCE, + D3D10_MESSAGE_ID_CREATERESOURCE_PRESENTATION_PRECLUDES_SHADER_RESOURCE, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_BLEND_ENABLE, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_INDEPENDENT_WRITE_MASKS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_STREAM_OUT, + D3D10_MESSAGE_ID_CREATERESOURCE_ONLY_VB_IB_FOR_BUFFERS, + D3D10_MESSAGE_ID_CREATERESOURCE_NO_AUTOGEN_FOR_VOLUMES, + D3D10_MESSAGE_ID_CREATERESOURCE_DXGI_FORMAT_R8G8B8A8_CANNOT_BE_SHARED, + D3D10_MESSAGE_ID_VSSHADERRESOURCES_NOT_SUPPORTED, + D3D10_MESSAGE_ID_GEOMETRY_SHADER_NOT_SUPPORTED, + D3D10_MESSAGE_ID_STREAM_OUT_NOT_SUPPORTED, + D3D10_MESSAGE_ID_TEXT_FILTER_NOT_SUPPORTED, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_SEPARATE_ALPHA_BLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_NO_MRT_BLEND, + D3D10_MESSAGE_ID_CREATEBLENDSTATE_OPERATION_NOT_SUPPORTED, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_NO_MIRRORONCE, + D3D10_MESSAGE_ID_DRAWINSTANCED_NOT_SUPPORTED, + D3D10_MESSAGE_ID_DRAWINDEXEDINSTANCED_NOT_SUPPORTED_BELOW_9_3, + D3D10_MESSAGE_ID_DRAWINDEXED_POINTLIST_UNSUPPORTED, + D3D10_MESSAGE_ID_SETBLENDSTATE_SAMPLE_MASK_CANNOT_BE_ZERO, + D3D10_MESSAGE_ID_CREATERESOURCE_DIMENSION_EXCEEDS_FEATURE_LEVEL_DEFINITION, + D3D10_MESSAGE_ID_CREATERESOURCE_ONLY_SINGLE_MIP_LEVEL_DEPTH_STENCIL_SUPPORTED, + D3D10_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_NEGATIVESCISSOR, + D3D10_MESSAGE_ID_SLOT_ZERO_MUST_BE_D3D10_INPUT_PER_VERTEX_DATA, + D3D10_MESSAGE_ID_CREATERESOURCE_NON_POW_2_MIPMAP, + D3D10_MESSAGE_ID_CREATESAMPLERSTATE_BORDER_NOT_SUPPORTED, + D3D10_MESSAGE_ID_OMSETRENDERTARGETS_NO_SRGB_MRT, + D3D10_MESSAGE_ID_COPYRESOURCE_NO_3D_MISMATCHED_UPDATES, + D3D10_MESSAGE_ID_D3D10L9_MESSAGES_END, +}} +STRUCT!{struct D3D10_MESSAGE { + Category: D3D10_MESSAGE_CATEGORY, + Severity: D3D10_MESSAGE_SEVERITY, + ID: D3D10_MESSAGE_ID, + pDescription: LPCSTR, + DescriptionByteLength: SIZE_T, +}} +STRUCT!{struct D3D10_INFO_QUEUE_FILTER_DESC { + NumCategories: UINT, + pCategoryList: *mut D3D10_MESSAGE_CATEGORY, + NumSeverities: UINT, + pSeverityList: *mut D3D10_MESSAGE_SEVERITY, + NumIDs: UINT, + pIDList: D3D10_MESSAGE_ID, +}} +STRUCT!{struct D3D10_INFO_QUEUE_FILTER { + AllowList: D3D10_INFO_QUEUE_FILTER_DESC, + DenyList: D3D10_INFO_QUEUE_FILTER_DESC, +}} +pub const D3D10_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT: DWORD = 1024; +RIDL!{#[uuid(0x1b940b17, 0x2642, 0x4d1f, 0xab, 0x1f, 0xb9, 0x9b, 0xad, 0x0c, 0x39, 0x5f)] +interface ID3D10InfoQueue(ID3D10InfoQueueVtbl): IUnknown(IUnknownVtbl) { + fn SetMessageCountLimit( + MessageCountLimit: UINT64, + ) -> HRESULT, + fn ClearStoredMessages() -> (), + fn GetMessage( + MessageIndex: UINT64, + pMessage: *mut D3D10_MESSAGE, + pMessageByteLength: *mut SIZE_T, + ) -> HRESULT, + fn GetNumMessagesAllowedByStorageFilter() -> UINT64, + fn GetNumMessagesDeniedByStorageFilter() -> UINT64, + fn GetNumStoredMessages() -> UINT64, + fn GetNumStoredMessagesAllowedByRetrievalFilter() -> UINT64, + fn GetNumMessagesDiscardedByMessageCountLimit() -> UINT64, + fn GetMessageCountLimit() -> UINT64, + fn AddStorageFilterEntries( + pFilter: *mut D3D10_INFO_QUEUE_FILTER, + ) -> HRESULT, + fn GetStorageFilter( + pFilter: *mut D3D10_INFO_QUEUE_FILTER, + pFilterByteLength: *mut SIZE_T, + ) -> HRESULT, + fn ClearStorageFilter() -> () , + fn PushEmptyStorageFilter() -> HRESULT, + fn PushCopyOfStorageFilter() -> HRESULT, + fn PushStorageFilter( + pFilter: *mut D3D10_INFO_QUEUE_FILTER, + ) -> HRESULT, + fn PopStorageFilter() -> (), + fn GetStorageFilterStackSize() -> UINT, + fn AddRetrievalFilterEntries( + pFilter: *mut D3D10_INFO_QUEUE_FILTER, + ) -> HRESULT, + fn GetRetrievalFilter( + pFilter: *mut D3D10_INFO_QUEUE_FILTER, + pFilterByteLength: *mut SIZE_T, + ) -> HRESULT, + fn ClearRetrievalFilter() -> (), + fn PushEmptyRetrievalFilter() -> HRESULT, + fn PushCopyOfRetrievalFilter() -> HRESULT, + fn PushRetrievalFilter( + pFilter: *mut D3D10_INFO_QUEUE_FILTER, + ) -> HRESULT, + fn PopRetrievalFilter() -> (), + fn GetRetrievalFilterStackSize() -> UINT, + fn AddMessage( + Category: D3D10_MESSAGE_CATEGORY, + Severity: D3D10_MESSAGE_SEVERITY, + ID: D3D10_MESSAGE_ID, + pDescription: LPCSTR, + ) -> HRESULT, + fn AddApplicationMessage( + Severity: D3D10_MESSAGE_SEVERITY, + pDescription: LPCSTR, + ) -> HRESULT, + fn SetBreakOnCategory( + Category: D3D10_MESSAGE_CATEGORY, + bEnable: BOOL, + ) -> HRESULT, + fn SetBreakOnSeverity( + Severity: D3D10_MESSAGE_SEVERITY, + bEnable: BOOL, + ) -> HRESULT, + fn SetBreakOnID( + ID: D3D10_MESSAGE_ID, + bEnable: BOOL, + ) -> HRESULT, + fn GetBreakOnCategory( + Category: D3D10_MESSAGE_CATEGORY, + ) -> BOOL, + fn GetBreakOnSeverity( + Severity: D3D10_MESSAGE_SEVERITY, + ) -> BOOL, + fn GetBreakOnID( + ID: D3D10_MESSAGE_ID, + ) -> BOOL, + fn SetMuteDebugOutput( + bMute: BOOL, + ) -> (), + fn GetMuteDebugOutput() -> BOOL, +}} DEFINE_GUID!{DXGI_DEBUG_D3D10, 0x243b4c52, 0x3606, 0x4d3a, 0x99, 0xd7, 0xa7, 0xe7, 0xb3, 0x3e, 0xd7, 0x06} DEFINE_GUID!{IID_ID3D10Debug, diff --git a/src/um/d3d10shader.rs b/src/um/d3d10shader.rs index 952fd6dc2..c8a173c54 100644 --- a/src/um/d3d10shader.rs +++ b/src/um/d3d10shader.rs @@ -3,13 +3,15 @@ // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms -use shared::minwindef::{BYTE, LPVOID, UINT}; -use um::d3d10::{D3D10_PRIMITIVE_TOPOLOGY, D3D10_SRV_DIMENSION}; +use ctypes::c_void; +use shared::basetsd::SIZE_T; +use shared::minwindef::{BOOL, BYTE, LPVOID, UINT}; +use um::d3d10::{D3D10_PRIMITIVE_TOPOLOGY, D3D10_SRV_DIMENSION, ID3D10Device}; use um::d3dcommon::{ D3D_CBUFFER_TYPE, D3D_INCLUDE_TYPE, D3D_NAME, D3D_REGISTER_COMPONENT_TYPE, D3D_RESOURCE_RETURN_TYPE, D3D_SHADER_CBUFFER_FLAGS, D3D_SHADER_INPUT_FLAGS, - D3D_SHADER_INPUT_TYPE, D3D_SHADER_MACRO, D3D_SHADER_VARIABLE_CLASS, D3D_SHADER_VARIABLE_FLAGS, - D3D_SHADER_VARIABLE_TYPE, ID3DInclude, + D3D_SHADER_INPUT_TYPE, D3D_SHADER_MACRO, D3D_SHADER_VARIABLE_CLASS, + D3D_SHADER_VARIABLE_FLAGS, D3D_SHADER_VARIABLE_TYPE, ID3D10Blob, ID3DInclude }; use um::unknwnbase::{IUnknown, IUnknownVtbl}; use um::winnt::{HRESULT, LPCSTR}; @@ -203,4 +205,67 @@ interface ID3D10ShaderReflection(ID3D10ShaderReflectionVtbl): IUnknown(IUnknownV pDesc: *mut D3D10_SIGNATURE_PARAMETER_DESC, ) -> HRESULT, }} -// TODO Some functions +extern "system" { + pub fn D3D10CompileShader( + pSrcData: LPCSTR, + SrcDataSize: SIZE_T, + pFileName: LPCSTR, + pDefines: *const D3D10_SHADER_MACRO, + pInclude: LPD3D10INCLUDE, + pFunctionName: LPCSTR, + pProfile: LPCSTR, + Flags: UINT, + ppShader: *mut *mut ID3D10Blob, + ppErrorMsgs: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10DisassembleShader( + pShader: *const c_void, + BytecodeLength: SIZE_T, + EnableColorCode: BOOL, + pComments: LPCSTR, + ppDisassembly: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10GetPixelShaderProfile( + pDevice: *mut ID3D10Device, + ) -> LPCSTR; + pub fn D3D10GetVertexShaderProfile( + pDevice: *mut ID3D10Device, + ) -> LPCSTR; + pub fn D3D10GetGeometryShaderProfile( + pDevice: *mut ID3D10Device, + ) -> LPCSTR; + pub fn D3D10ReflectShader( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppDisassembly: *mut *mut ID3D10ShaderReflection, + ) -> HRESULT; + pub fn D3D10PreprocessShader( + pSrcData: LPCSTR, + SrcDataSize: SIZE_T, + pFileName: LPCSTR, + pDefines: *const D3D10_SHADER_MACRO, + pInclude: LPD3D10INCLUDE, + ppShaderText: *mut *mut ID3D10Blob, + ppErrorMsgs: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10GetInputSignatureBlob( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppSignatureBlob: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10GetOutputSignatureBlob( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppSignatureBlob: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10GetInputAndOutputSignatureBlob( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppSignatureBlob: *mut *mut ID3D10Blob, + ) -> HRESULT; + pub fn D3D10GetShaderDebugInfo ( + pShaderBytecode: *const c_void, + BytecodeLength: SIZE_T, + ppDebugInfo: *mut *mut ID3D10Blob, + ) -> HRESULT; +}