Mercurial > projects > ddbg_continued
diff win32/directx/d3d10.d @ 1:4a9dcbd9e54f
-files of 0.13 beta
-fixes so that it now compiles with the current dmd version
| author | marton@basel.hu |
|---|---|
| date | Tue, 05 Apr 2011 20:44:01 +0200 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/win32/directx/d3d10.d Tue Apr 05 20:44:01 2011 +0200 @@ -0,0 +1,1229 @@ +/***********************************************************************\ +* d3d10.d * +* * +* Windows API header module * +* * +* Placed into public domain * +\***********************************************************************/ +module win32.directx.d3d10; + +private import win32.windows; + +public import win32.directx.dxgitype; +public import win32.directx.dxgi; +public import win32.directx.d3d10misc; +public import win32.directx.d3d10shader; +public import win32.directx.d3d10effect; + +pragma(lib, "d3d10.lib"); + +const D3D10_16BIT_INDEX_STRIP_CUT_VALUE = 0xffff; +const D3D10_32BIT_INDEX_STRIP_CUT_VALUE = 0xffffffff; +const D3D10_8BIT_INDEX_STRIP_CUT_VALUE = 0xff; +const D3D10_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT = 9; +const D3D10_CLIP_OR_CULL_DISTANCE_COUNT = 8; +const D3D10_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT = 2; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT = 14; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS = 4; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT = 32; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT = 15; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT = 15; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const D3D10_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT = 64; +const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS = 4; +const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT = 1; +const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST = 1; +const D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS = 1; +const D3D10_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT = 32; +const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS = 1; +const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT = 128; +const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST = 1; +const D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS = 1; +const D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT = 128; +const D3D10_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS = 1; +const D3D10_COMMONSHADER_SAMPLER_REGISTER_COUNT = 16; +const D3D10_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST = 1; +const D3D10_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS = 1; +const D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT = 16; +const D3D10_COMMONSHADER_SUBROUTINE_NESTING_LIMIT = 32; +const D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENTS = 4; +const D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_COMMONSHADER_TEMP_REGISTER_COUNT = 4096; +const D3D10_COMMONSHADER_TEMP_REGISTER_READS_PER_INST = 3; +const D3D10_COMMONSHADER_TEMP_REGISTER_READ_PORTS = 3; +const D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX = 10; +const D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN = -10; +const D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE = -8; +const D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE = 7; +const D3D10_DEFAULT_BLEND_FACTOR_ALPHA = 1.0f; +const D3D10_DEFAULT_BLEND_FACTOR_BLUE = 1.0f; +const D3D10_DEFAULT_BLEND_FACTOR_GREEN = 1.0f; +const D3D10_DEFAULT_BLEND_FACTOR_RED = 1.0f; +const D3D10_DEFAULT_BORDER_COLOR_COMPONENT = 0.0f; +const D3D10_DEFAULT_DEPTH_BIAS = 0; +const D3D10_DEFAULT_DEPTH_BIAS_CLAMP = 0.0f; +const D3D10_DEFAULT_MAX_ANISOTROPY = 16.0f; +const D3D10_DEFAULT_MIP_LOD_BIAS = 0.0f; +const D3D10_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; +const D3D10_DEFAULT_SAMPLE_MASK = 0xffffffff; +const D3D10_DEFAULT_SCISSOR_ENDX = 0; +const D3D10_DEFAULT_SCISSOR_ENDY = 0; +const D3D10_DEFAULT_SCISSOR_STARTX = 0; +const D3D10_DEFAULT_SCISSOR_STARTY = 0; +const D3D10_DEFAULT_SLOPE_SCALED_DEPTH_BIAS = 0.0f; +const D3D10_DEFAULT_STENCIL_READ_MASK = 0xff; +const D3D10_DEFAULT_STENCIL_REFERENCE = 0; +const D3D10_DEFAULT_STENCIL_WRITE_MASK = 0xff; +const D3D10_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; +const D3D10_DEFAULT_VIEWPORT_HEIGHT = 0; +const D3D10_DEFAULT_VIEWPORT_MAX_DEPTH = 0.0f; +const D3D10_DEFAULT_VIEWPORT_MIN_DEPTH = 0.0f; +const D3D10_DEFAULT_VIEWPORT_TOPLEFTX = 0; +const D3D10_DEFAULT_VIEWPORT_TOPLEFTY = 0; +const D3D10_DEFAULT_VIEWPORT_WIDTH = 0; +const D3D10_FLOAT16_FUSED_TOLERANCE_IN_ULP = 0.6; +const D3D10_FLOAT32_MAX = 3.402823466e+38f; +const D3D10_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP = 0.6f; +const D3D10_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR = 2.4f; +const D3D10_FLOAT_TO_SRGB_EXPONENT_NUMERATOR = 1.0f; +const D3D10_FLOAT_TO_SRGB_OFFSET = 0.055f; +const D3D10_FLOAT_TO_SRGB_SCALE_1 = 12.92f; +const D3D10_FLOAT_TO_SRGB_SCALE_2 = 1.055f; +const D3D10_FLOAT_TO_SRGB_THRESHOLD = 0.0031308f; +const D3D10_FTOI_INSTRUCTION_MAX_INPUT = 2147483647.999f; +const D3D10_FTOI_INSTRUCTION_MIN_INPUT = -2147483648.999f; +const D3D10_FTOU_INSTRUCTION_MAX_INPUT = 4294967295.999f; +const D3D10_FTOU_INSTRUCTION_MIN_INPUT = 0.0f; +const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS = 1; +const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_GS_INPUT_PRIM_CONST_REGISTER_COUNT = 1; +const D3D10_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST = 2; +const D3D10_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS = 1; +const D3D10_GS_INPUT_REGISTER_COMPONENTS = 4; +const D3D10_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_GS_INPUT_REGISTER_COUNT = 16; +const D3D10_GS_INPUT_REGISTER_READS_PER_INST = 2; +const D3D10_GS_INPUT_REGISTER_READ_PORTS = 1; +const D3D10_GS_INPUT_REGISTER_VERTICES = 6; +const D3D10_GS_OUTPUT_ELEMENTS = 32; +const D3D10_GS_OUTPUT_REGISTER_COMPONENTS = 4; +const D3D10_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_GS_OUTPUT_REGISTER_COUNT = 32; +const D3D10_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES = 0; +const D3D10_IA_DEFAULT_PRIMITIVE_TOPOLOGY = 0; +const D3D10_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES = 0; +const D3D10_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT = 1; +const D3D10_IA_INSTANCE_ID_BIT_COUNT = 32; +const D3D10_IA_INTEGER_ARITHMETIC_BIT_COUNT = 32; +const D3D10_IA_PRIMITIVE_ID_BIT_COUNT = 32; +const D3D10_IA_VERTEX_ID_BIT_COUNT = 32; +const D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT = 16; +const D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS = 64; +const D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT = 16; +const D3D10_INTEGER_DIVIDE_BY_ZERO_QUOTIENT = 0xffffffff; +const D3D10_INTEGER_DIVIDE_BY_ZERO_REMAINDER = 0xffffffff; +const D3D10_LINEAR_GAMMA = 1.0f; +const D3D10_MAX_BORDER_COLOR_COMPONENT = 1.0f; +const D3D10_MAX_DEPTH = 1.0f; +const D3D10_MAX_MAXANISOTROPY = 16; +const D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; +const D3D10_MAX_POSITION_VALUE = 3.402823466e+34f; +const D3D10_MAX_TEXTURE_DIMENSION_2_TO_EXP = 17; +const D3D10_MIN_BORDER_COLOR_COMPONENT = 0.0f; +const D3D10_MIN_DEPTH = 0.0f; +const D3D10_MIN_MAXANISOTROPY = 0; +const D3D10_MIP_LOD_BIAS_MAX = 15.99f; +const D3D10_MIP_LOD_BIAS_MIN = -16.0f; +const D3D10_MIP_LOD_FRACTIONAL_BIT_COUNT = 6; +const D3D10_MIP_LOD_RANGE_BIT_COUNT = 8; +const D3D10_MULTISAMPLE_ANTIALIAS_LINE_WIDTH = 1.4f; +const D3D10_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT = 0; +const D3D10_PIXEL_ADDRESS_RANGE_BIT_COUNT = 13; +const D3D10_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT = 15; +const D3D10_PS_FRONTFACING_DEFAULT_VALUE = 0xffffffff; +const D3D10_PS_FRONTFACING_FALSE_VALUE = 0; +const D3D10_PS_FRONTFACING_TRUE_VALUE = 0xffffffff; +const D3D10_PS_INPUT_REGISTER_COMPONENTS = 4; +const D3D10_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_PS_INPUT_REGISTER_COUNT = 32; +const D3D10_PS_INPUT_REGISTER_READS_PER_INST = 2; +const D3D10_PS_INPUT_REGISTER_READ_PORTS = 1; +const D3D10_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.0f; +const D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS = 1; +const D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_PS_OUTPUT_DEPTH_REGISTER_COUNT = 1; +const D3D10_PS_OUTPUT_REGISTER_COMPONENTS = 4; +const D3D10_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_PS_OUTPUT_REGISTER_COUNT = 8; +const D3D10_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT = 0.5f; +const D3D10_REQ_BLEND_OBJECT_COUNT_PER_CONTEXT = 4096; +const D3D10_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP = 27; +const D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const D3D10_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_CONTEXT = 4096; +const D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 32; +const D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP = 32; +const D3D10_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION = 8192; +const D3D10_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT = 1024; +const D3D10_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT = 4096; +const D3D10_REQ_MAXANISOTROPY = 16; +const D3D10_REQ_MIP_LEVELS = 14; +const D3D10_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES = 2048; +const D3D10_REQ_RASTERIZER_OBJECT_COUNT_PER_CONTEXT = 4096; +const D3D10_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH = 8192; +const D3D10_REQ_RESOURCE_SIZE_IN_MEGABYTES = 128; +const D3D10_REQ_RESOURCE_VIEW_COUNT_PER_CONTEXT_2_TO_EXP = 20; +const D3D10_REQ_SAMPLER_OBJECT_COUNT_PER_CONTEXT = 4096; +const D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION = 512; +const D3D10_REQ_TEXTURE1D_U_DIMENSION = 8192; +const D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION = 512; +const D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION = 8192; +const D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION = 2048; +const D3D10_REQ_TEXTURECUBE_DIMENSION = 8192; +const D3D10_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL = 0; +const D3D10_SHADER_MAJOR_VERSION = 4; +const D3D10_SHADER_MINOR_VERSION = 0; +const D3D10_SHIFT_INSTRUCTION_PAD_VALUE = 0; +const D3D10_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT = 5; +const D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; +const D3D10_SO_BUFFER_MAX_STRIDE_IN_BYTES = 2048; +const D3D10_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES = 256; +const D3D10_SO_BUFFER_SLOT_COUNT = 4; +const D3D10_SO_DDI_REGISTER_INDEX_DENOTING_GAP = 0xffffffff; +const D3D10_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER = 1; +const D3D10_SO_SINGLE_BUFFER_COMPONENT_LIMIT = 64; +const D3D10_SRGB_GAMMA = 2.2f; +const D3D10_SRGB_TO_FLOAT_DENOMINATOR_1 = 12.92f; +const D3D10_SRGB_TO_FLOAT_DENOMINATOR_2 = 1.055f; +const D3D10_SRGB_TO_FLOAT_EXPONENT = 2.4f; +const D3D10_SRGB_TO_FLOAT_OFFSET = 0.055f; +const D3D10_SRGB_TO_FLOAT_THRESHOLD = 0.04045f; +const D3D10_SRGB_TO_FLOAT_TOLERANCE_IN_ULP = 0.5f; +const D3D10_STANDARD_COMPONENT_BIT_COUNT = 32; +const D3D10_STANDARD_COMPONENT_BIT_COUNT_DOUBLED = 64; +const D3D10_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE = 4; +const D3D10_STANDARD_PIXEL_COMPONENT_COUNT = 128; +const D3D10_STANDARD_PIXEL_ELEMENT_COUNT = 32; +const D3D10_STANDARD_VECTOR_SIZE = 4; +const D3D10_STANDARD_VERTEX_ELEMENT_COUNT = 16; +const D3D10_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT = 64; +const D3D10_SUBPIXEL_FRACTIONAL_BIT_COUNT = 8; +const D3D10_SUBTEXEL_FRACTIONAL_BIT_COUNT = 6; +const D3D10_TEXEL_ADDRESS_RANGE_BIT_COUNT = 18; +const D3D10_UNBOUND_MEMORY_ACCESS_RESULT = 0; +const D3D10_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; +const D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; +const D3D10_VIEWPORT_BOUNDS_MAX = 16383; +const D3D10_VIEWPORT_BOUNDS_MIN = -16384; +const D3D10_VS_INPUT_REGISTER_COMPONENTS = 4; +const D3D10_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_VS_INPUT_REGISTER_COUNT = 16; +const D3D10_VS_INPUT_REGISTER_READS_PER_INST = 2; +const D3D10_VS_INPUT_REGISTER_READ_PORTS = 1; +const D3D10_VS_OUTPUT_REGISTER_COMPONENTS = 4; +const D3D10_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT = 32; +const D3D10_VS_OUTPUT_REGISTER_COUNT = 16; +const D3D10_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT = 10; +const D3D10_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP = 25; +const D3D10_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP = 25; +const D3D_MAJOR_VERSION = 10; +const D3D_MINOR_VERSION = 0; +const D3D_SPEC_DATE_DAY = 8; +const D3D_SPEC_DATE_MONTH = 8; +const D3D_SPEC_DATE_YEAR = 2006; +const D3D_SPEC_VERSION = 1.050005; + +const _FACD3D10 = 0x879; +const _FACD3D10DEBUG = _FACD3D10 + 1; + +HRESULT MAKE_D3D10_HRESULT(T)(T code) { + return MAKE_HRESULT(1, _FACD3D10, code); +} + +HRESULT MAKE_D3D10_STATUS(T)(T code) { + return MAKE_HRESULT(0, _FACD3D10, code); +} + +const D3D10_ERROR_TOO_MANY_UNIQUE_STATE_OBJECTS = MAKE_D3D10_HRESULT(1); +const D3D10_ERROR_FILE_NOT_FOUND = MAKE_D3D10_HRESULT(2); + +enum D3D10_INPUT_CLASSIFICATION { + D3D10_INPUT_PER_VERTEX_DATA = 0, + D3D10_INPUT_PER_INSTANCE_DATA = 1 +} + +const D3D10_APPEND_ALIGNED_ELEMENT = 0xffffffff; + +struct D3D10_INPUT_ELEMENT_DESC { + LPCSTR SemanticName; + UINT SemanticIndex; + DXGI_FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + D3D10_INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; +} + +enum D3D10_FILL_MODE { + D3D10_FILL_WIREFRAME = 2, + D3D10_FILL_SOLID = 3 +} + +enum D3D10_PRIMITIVE_TOPOLOGY { + D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED = 0, + D3D10_PRIMITIVE_TOPOLOGY_POINTLIST = 1, + D3D10_PRIMITIVE_TOPOLOGY_LINELIST = 2, + D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP = 3, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5, + D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10, + D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12, + D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13 +} + +enum D3D10_PRIMITIVE { + D3D10_PRIMITIVE_UNDEFINED = 0, + D3D10_PRIMITIVE_POINT = 1, + D3D10_PRIMITIVE_LINE = 2, + D3D10_PRIMITIVE_TRIANGLE = 3, + D3D10_PRIMITIVE_LINE_ADJ = 6, + D3D10_PRIMITIVE_TRIANGLE_ADJ = 7 +} + +enum D3D10_CULL_MODE { + D3D10_CULL_NONE = 1, + D3D10_CULL_FRONT, + D3D10_CULL_BACK +} + +struct D3D10_SO_DECLARATION_ENTRY { + LPCSTR SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; +} + +struct D3D10_VIEWPORT { + INT TopLeftX; + INT TopLeftY; + UINT Width; + UINT Height; + FLOAT MinDepth; + FLOAT MaxDepth; +} + +enum D3D10_RESOURCE_DIMENSION { + D3D10_RESOURCE_DIMENSION_UNKNOWN = 0, + D3D10_RESOURCE_DIMENSION_BUFFER, + D3D10_RESOURCE_DIMENSION_TEXTURE1D, + D3D10_RESOURCE_DIMENSION_TEXTURE2D, + D3D10_RESOURCE_DIMENSION_TEXTURE3D +} + +enum D3D10_SRV_DIMENSION { + D3D10_SRV_DIMENSION_UNKNOWN = 0, + D3D10_SRV_DIMENSION_BUFFER, + D3D10_SRV_DIMENSION_TEXTURE1D, + D3D10_SRV_DIMENSION_TEXTURE1DARRAY, + D3D10_SRV_DIMENSION_TEXTURE2D, + D3D10_SRV_DIMENSION_TEXTURE2DARRAY, + D3D10_SRV_DIMENSION_TEXTURE2DMS, + D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_SRV_DIMENSION_TEXTURE3D, + D3D10_SRV_DIMENSION_TEXTURECUBE +} + +enum D3D10_DSV_DIMENSION { + D3D10_DSV_DIMENSION_UNKNOWN = 0, + D3D10_DSV_DIMENSION_TEXTURE1D, + D3D10_DSV_DIMENSION_TEXTURE1DARRAY, + D3D10_DSV_DIMENSION_TEXTURE2D, + D3D10_DSV_DIMENSION_TEXTURE2DARRAY, + D3D10_DSV_DIMENSION_TEXTURE2DMS, + D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY6 +} + +enum D3D10_RTV_DIMENSION { + D3D10_RTV_DIMENSION_UNKNOWN = 0, + D3D10_RTV_DIMENSION_BUFFER, + D3D10_RTV_DIMENSION_TEXTURE1D, + D3D10_RTV_DIMENSION_TEXTURE1DARRAY, + D3D10_RTV_DIMENSION_TEXTURE2D, + D3D10_RTV_DIMENSION_TEXTURE2DARRAY, + D3D10_RTV_DIMENSION_TEXTURE2DMS, + D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY, + D3D10_RTV_DIMENSION_TEXTURE3D +} + +enum D3D10_USAGE { + D3D10_USAGE_DEFAULT = 0, + D3D10_USAGE_IMMUTABLE, + D3D10_USAGE_DYNAMIC, + D3D10_USAGE_STAGING +} + +enum D3D10_BIND_FLAG { + D3D10_BIND_VERTEX_BUFFER = 0x01, + D3D10_BIND_INDEX_BUFFER = 0x02, + D3D10_BIND_CONSTANT_BUFFER = 0x04, + D3D10_BIND_SHADER_RESOURCE = 0x08, + D3D10_BIND_STREAM_OUTPUT = 0x10, + D3D10_BIND_RENDER_TARGET = 0x20, + D3D10_BIND_DEPTH_STENCIL = 0x40 +} + +enum D3D10_CPU_ACCESS_FLAG { + D3D10_CPU_ACCESS_WRITE = 0x10000, + D3D10_CPU_ACCESS_READ = 0x20000 +} + +enum D3D10_RESOURCE_MISC_FLAG { + D3D10_RESOURCE_MISC_GENERATE_MIPS = 0x01, + D3D10_RESOURCE_MISC_SHARED = 0x02, + D3D10_RESOURCE_MISC_TEXTURECUBE = 0x04 +} + +enum D3D10_MAP { + D3D10_MAP_READ = 1, + D3D10_MAP_WRITE, + D3D10_MAP_READ_WRITE, + D3D10_MAP_WRITE_DISCARD, + D3D10_MAP_WRITE_NO_OVERWRITE +} + +enum D3D10_MAP_FLAG { + D3D10_MAP_FLAG_DO_NOT_WAIT = 0x100000 +} + +enum D3D10_RAISE_FLAG { + D3D10_RAISE_FLAG_DRIVER_INTERNAL_ERROR = 0x01 +} + +enum D3D10_CLEAR_FLAG { + D3D10_CLEAR_DEPTH = 0x01, + D3D10_CLEAR_STENCIL = 0x02 +} + +alias RECT D3D10_RECT; + +struct D3D10_BOX { + UINT left; + UINT top; + UINT front; + UINT right; + UINT bottom; + UINT back; +} + +extern (Windows) interface ID3D10DeviceChild : IUnknown { + //extern(Windows) : + void GetDevice(ID3D10Device* ppDevice); + HRESULT GetPrivateData(REFGUID guid, UINT *pDataSize, void *pData); + HRESULT SetPrivateData(REFGUID guid, UINT DataSize, void *pData); + HRESULT SetPrivateDataInterface(REFGUID guid, IUnknown pData); +} + +enum D3D10_COMPARISON_FUNC { + D3D10_COMPARISON_NEVER = 1, + D3D10_COMPARISON_LESS, + D3D10_COMPARISON_EQUAL, + D3D10_COMPARISON_LESS_EQUAL, + D3D10_COMPARISON_GREATER, + D3D10_COMPARISON_NOT_EQUAL, + D3D10_COMPARISON_GREATER_EQUAL, + D3D10_COMPARISON_ALWAYS +} + +enum D3D10_DEPTH_WRITE_MASK { + D3D10_DEPTH_WRITE_MASK_ZERO = 0, + D3D10_DEPTH_WRITE_MASK_ALL +} + +enum D3D10_STENCIL_OP { + D3D10_STENCIL_OP_KEEP = 1, + D3D10_STENCIL_OP_ZERO, + D3D10_STENCIL_OP_REPLACE, + D3D10_STENCIL_OP_INCR_SAT, + D3D10_STENCIL_OP_DECR_SAT, + D3D10_STENCIL_OP_INVERT, + D3D10_STENCIL_OP_INCR, + D3D10_STENCIL_OP_DECR +} + +struct D3D10_DEPTH_STENCILOP_DESC { + D3D10_STENCIL_OP StencilFailOp; + D3D10_STENCIL_OP StencilDepthFailOp; + D3D10_STENCIL_OP StencilPassOp; + D3D10_COMPARISON_FUNC StencilFunc; +} + +struct D3D10_DEPTH_STENCIL_DESC { + BOOL DepthEnable; + D3D10_DEPTH_WRITE_MASK DepthWriteMask; + D3D10_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D10_DEPTH_STENCILOP_DESC FrontFace; + D3D10_DEPTH_STENCILOP_DESC BackFace; +} + +interface ID3D10DepthStencilState : ID3D10DeviceChild { + extern(Windows) : + void GetDesc(D3D10_DEPTH_STENCIL_DESC *pDesc); +} + +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 D3D10_BLEND_OP { + D3D10_BLEND_OP_ADD = 1, + D3D10_BLEND_OP_SUBTRACT, + D3D10_BLEND_OP_REV_SUBTRACT, + D3D10_BLEND_OP_MIN, + D3D10_BLEND_OP_MAX +} + +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 D3D10_BLEND_DESC { + BOOL AlphaToCoverageEnable; + BOOL[8] BlendEnable; + D3D10_BLEND SrcBlend; + D3D10_BLEND DestBlend; + D3D10_BLEND_OP BlendOp; + D3D10_BLEND SrcBlendAlpha; + D3D10_BLEND DestBlendAlpha; + D3D10_BLEND_OP BlendOpAlpha; + UINT8[8] RenderTargetWriteMask; +} + +interface ID3D10BlendState : ID3D10DeviceChild { + extern(Windows) : + void GetDesc(D3D10_BLEND_DESC *pDesc); +} + +struct D3D10_RASTERIZER_DESC { + D3D10_FILL_MODE FillMode; + D3D10_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; +} + +interface ID3D10RasterizerState : ID3D10DeviceChild { + extern(Windows) : + void GetDesc(D3D10_RASTERIZER_DESC *pDesc); +} + +UINT D3D10CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT MipLevels) { + return MipSlice + ArraySlice * MipLevels; +} + +struct D3D10_SUBRESOURCE_DATA { + void *pSysMem; + UINT SysMemPitch; + UINT SysMemSlicePitch; +} + +interface ID3D10Resource : ID3D10DeviceChild { + extern(Windows) : + void GetType(D3D10_RESOURCE_DIMENSION *rType); + void SetEvictionPriority(UINT EvictionPriority); + UINT GetEvictionPriority(); +} + +struct D3D10_BUFFER_DESC { + UINT ByteWidth; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} + +interface ID3D10Buffer : ID3D10Resource { + extern(Windows) : + HRESULT Map(D3D10_MAP MapType, UINT MapFlags, void **ppData); + void Unmap(); + void GetDesc(D3D10_BUFFER_DESC *pDesc); +} + +struct D3D10_TEXTURE1D_DESC { + UINT Width; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} + +interface ID3D10Texture1D : ID3D10Resource { + extern(Windows) : + HRESULT Map(UINT Subresource, D3D10_MAP MapType, UINT MapFlags, void **ppData); + void Unmap(UINT Subresource); + void GetDesc(D3D10_TEXTURE1D_DESC *pDesc); +} + +struct D3D10_TEXTURE2D_DESC { + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} + +struct D3D10_MAPPED_TEXTURE2D { + void *pData; + UINT RowPitch; +} + +interface ID3D10Texture2D : ID3D10Resource { + extern(Windows) : + HRESULT Map(UINT Subresource, D3D10_MAP MapType, UINT MapFlags, D3D10_MAPPED_TEXTURE2D *pMappedTex2D); + void Unmap(UINT Subresource); + void GetDesc(D3D10_TEXTURE2D_DESC *pDesc); +} + +struct D3D10_TEXTURE3D_DESC { + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + DXGI_FORMAT Format; + D3D10_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} + +struct D3D10_MAPPED_TEXTURE3D { + void *pData; + UINT RowPitch; + UINT DepthPitch; +} + +interface ID3D10Texture3D : ID3D10Resource { + extern(Windows) : + HRESULT Map(UINT Subresource, D3D10_MAP MapType, UINT MapFlags, D3D10_MAPPED_TEXTURE3D *pMappedTex3D); + void Unmap(UINT Subresource); + void GetDesc(D3D10_TEXTURE3D_DESC *pDesc); +} + +enum D3D10_TEXTURECUBE_FACE { + D3D10_TEXTURECUBE_FACE_POSITIVE_X = 0, + D3D10_TEXTURECUBE_FACE_NEGATIVE_X, + D3D10_TEXTURECUBE_FACE_POSITIVE_Y, + D3D10_TEXTURECUBE_FACE_NEGATIVE_Y, + D3D10_TEXTURECUBE_FACE_POSITIVE_Z, + D3D10_TEXTURECUBE_FACE_NEGATIVE_Z +} + +interface ID3D10View : ID3D10DeviceChild { + extern(Windows) : + void GetResource(ID3D10Resource *ppResource); +} + +struct D3D10_BUFFER_SRV { + UINT ElementOffset; + UINT ElementWidth; +} + +struct D3D10_TEX1D_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} + +struct D3D10_TEX1D_ARRAY_SRV { + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX2D_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} + +struct D3D10_TEX2D_ARRAY_SRV { + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX3D_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} + +struct D3D10_TEXCUBE_SRV { + UINT MostDetailedMip; + UINT MipLevels; +} + +struct D3D10_TEX2DMS_SRV { + UINT UnusedField_NothingToDefine; +} + +struct D3D10_TEX2DMS_ARRAY_SRV { + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_SHADER_RESOURCE_VIEW_DESC { + DXGI_FORMAT Format; + D3D10_SRV_DIMENSION ViewDimension; + union { + D3D10_BUFFER_SRV Buffer; + D3D10_TEX1D_SRV Texture1D; + D3D10_TEX1D_ARRAY_SRV Texture1DArray; + D3D10_TEX2D_SRV Texture2D; + D3D10_TEX2D_ARRAY_SRV Texture2DArray; + D3D10_TEX2DMS_SRV Texture2DMS; + D3D10_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D10_TEX3D_SRV Texture3D; + D3D10_TEXCUBE_SRV TextureCube; + } +} + +interface ID3D10ShaderResourceView : ID3D10View { + extern(Windows) : + void GetDesc(D3D10_SHADER_RESOURCE_VIEW_DESC *pDesc); +} + +struct D3D10_BUFFER_RTV { + UINT ElementOffset; + UINT ElementWidth; +} + +struct D3D10_TEX1D_RTV { + UINT MipSlice; +} + +struct D3D10_TEX1D_ARRAY_RTV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX2D_RTV { + UINT MipSlice; +} + +struct D3D10_TEX2DMS_RTV { + UINT UnusedField_NothingToDefine; +} + +struct D3D10_TEX2D_ARRAY_RTV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX2DMS_ARRAY_RTV { + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX3D_RTV { + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} + +struct D3D10_RENDER_TARGET_VIEW_DESC { + DXGI_FORMAT Format; + D3D10_RTV_DIMENSION ViewDimension; + union { + D3D10_BUFFER_RTV Buffer; + D3D10_TEX1D_RTV Texture1D; + D3D10_TEX1D_ARRAY_RTV Texture1DArray; + D3D10_TEX2D_RTV Texture2D; + D3D10_TEX2D_ARRAY_RTV Texture2DArray; + D3D10_TEX2DMS_RTV Texture2DMS; + D3D10_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D10_TEX3D_RTV Texture3D; + } +} + +interface ID3D10RenderTargetView : ID3D10View { + extern(Windows) : + void GetDesc(D3D10_RENDER_TARGET_VIEW_DESC *pDesc); +} + +struct D3D10_TEX1D_DSV { + UINT MipSlice; +} + +struct D3D10_TEX1D_ARRAY_DSV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX2D_DSV { + UINT MipSlice; +} + +struct D3D10_TEX2D_ARRAY_DSV { + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_TEX2DMS_DSV { + UINT UnusedField_NothingToDefine; +} + +struct D3D10_TEX2DMS_ARRAY_DSV { + UINT FirstArraySlice; + UINT ArraySize; +} + +struct D3D10_DEPTH_STENCIL_VIEW_DESC { + DXGI_FORMAT Format; + D3D10_DSV_DIMENSION ViewDimension; + union { + D3D10_TEX1D_DSV Texture1D; + D3D10_TEX1D_ARRAY_DSV Texture1DArray; + D3D10_TEX2D_DSV Texture2D; + D3D10_TEX2D_ARRAY_DSV Texture2DArray; + D3D10_TEX2DMS_DSV Texture2DMS; + D3D10_TEX2DMS_ARRAY_DSV Texture2DMSArray; + } +} + +interface ID3D10DepthStencilView : ID3D10View { + extern(Windows) : + void GetDesc(D3D10_DEPTH_STENCIL_VIEW_DESC *pDesc); +} + +interface ID3D10VertexShader : ID3D10DeviceChild { } + +interface ID3D10GeometryShader : ID3D10DeviceChild { } + +interface ID3D10PixelShader : ID3D10DeviceChild { } + +interface ID3D10InputLayout : ID3D10DeviceChild { } + +enum D3D10_FILTER { + D3D10_FILTER_MIN_MAG_MIP_POINT = 0x00, + D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01, + D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04, + D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05, + 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 D3D10_FILTER_TYPE { + D3D10_FILTER_TYPE_POINT = 0, + D3D10_FILTER_TYPE_LINEAR +} + +const D3D10_FILTER_TYPE_MASK = 0x03; + +const D3D10_MIN_FILTER_SHIFT = 4; + +const D3D10_MAG_FILTER_SHIFT = 2; + +const D3D10_MIP_FILTER_SHIFT = 0; + +const D3D10_COMPARISON_FILTERING_BIT = 0x80; + +const D3D10_ANISOTROPIC_FILTERING_BIT = 0x40; + +const D3D10_TEXT_1BIT_BIT = 0x80000000; + +D3D10_FILTER D3D10_ENCODE_BASIC_FILTER(int min, int mag, int mip, bool bComparison) { + return cast(D3D10_FILTER)(((bComparison) ? D3D10_COMPARISON_FILTERING_BIT : 0) | + ((min & D3D10_FILTER_TYPE_MASK) << D3D10_MIN_FILTER_SHIFT) | + ((mag & D3D10_FILTER_TYPE_MASK) << D3D10_MAG_FILTER_SHIFT) | + ((mip & D3D10_FILTER_TYPE_MASK) << D3D10_MIP_FILTER_SHIFT)); +} + +D3D10_FILTER D3D10_ENCODE_ANISOTROPIC_FILTER(bool bComparison) { + return cast(D3D10_FILTER)(D3D10_ANISOTROPIC_FILTERING_BIT | + D3D10_ENCODE_BASIC_FILTER(D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR, + D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR, D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR, + bComparison)); +} + +D3D10_FILTER_TYPE D3D10_DECODE_MIN_FILTER(D3D10_FILTER d3d10Filter) { + return cast(D3D10_FILTER_TYPE)((d3d10Filter >> D3D10_MIN_FILTER_SHIFT) & D3D10_FILTER_TYPE_MASK); +} + +D3D10_FILTER_TYPE D3D10_DECODE_MAG_FILTER(D3D10_FILTER d3d10Filter) { + return cast(D3D10_FILTER_TYPE)((d3d10Filter >> D3D10_MAG_FILTER_SHIFT) & D3D10_FILTER_TYPE_MASK); +} + +D3D10_FILTER_TYPE D3D10_DECODE_MIP_FILTER(D3D10_FILTER d3d10Filter) { + return cast(D3D10_FILTER_TYPE)((d3d10Filter >> D3D10_MIP_FILTER_SHIFT) & D3D10_FILTER_TYPE_MASK); +} + +bool D3D10_DECODE_IS_COMPARISON_FILTER(D3D10_FILTER d3d10Filter) { + return (d3d10Filter & D3D10_COMPARISON_FILTERING_BIT) == D3D10_COMPARISON_FILTERING_BIT; +} + +bool D3D10_DECODE_IS_ANISOTROPIC_FILTER(D3D10_FILTER d3d10Filter) { + return ((d3d10Filter & D3D10_ANISOTROPIC_FILTERING_BIT) && + (D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR == D3D10_DECODE_MIN_FILTER(d3d10Filter)) && + (D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR == D3D10_DECODE_MAG_FILTER(d3d10Filter)) && + (D3D10_FILTER_TYPE.D3D10_FILTER_TYPE_LINEAR == D3D10_DECODE_MIP_FILTER(d3d10Filter))); +} + +bool D3D10_DECODE_IS_TEXT_1BIT_FILTER(D3D10_FILTER d3d10Filter) { + return d3d10Filter == D3D10_TEXT_1BIT_BIT; +} + +enum D3D10_TEXTURE_ADDRESS_MODE { + D3D10_TEXTURE_ADDRESS_WRAP = 1, + D3D10_TEXTURE_ADDRESS_MIRROR, + D3D10_TEXTURE_ADDRESS_CLAMP, + D3D10_TEXTURE_ADDRESS_BORDER, + D3D10_TEXTURE_ADDRESS_MIRROR_ONCE +} + +struct D3D10_SAMPLER_DESC { + D3D10_FILTER Filter; + D3D10_TEXTURE_ADDRESS_MODE AddressU; + D3D10_TEXTURE_ADDRESS_MODE AddressV; + D3D10_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D10_COMPARISON_FUNC ComparisonFunc; + FLOAT[4] BorderColor; + FLOAT MinLOD; + FLOAT MaxLOD; +} + +interface ID3D10SamplerState : ID3D10DeviceChild { + extern(Windows) : + void GetDesc(D3D10_SAMPLER_DESC *pDesc); +} + +enum D3D10_FORMAT_SUPPORT { + D3D10_FORMAT_SUPPORT_BUFFER = 0x000001, + D3D10_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x000002, + D3D10_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x000004, + D3D10_FORMAT_SUPPORT_SO_BUFFER = 0x000008, + D3D10_FORMAT_SUPPORT_TEXTURE1D = 0x000010, + D3D10_FORMAT_SUPPORT_TEXTURE2D = 0x000020, + D3D10_FORMAT_SUPPORT_TEXTURE3D = 0x000040, + D3D10_FORMAT_SUPPORT_TEXTURECUBE = 0x000080, + D3D10_FORMAT_SUPPORT_SHADER_LOAD = 0x000100, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE = 0x000200, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x000400, + D3D10_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x000800, + D3D10_FORMAT_SUPPORT_MIP = 0x001000, + D3D10_FORMAT_SUPPORT_MIP_AUTOGEN = 0x002000, + D3D10_FORMAT_SUPPORT_RENDER_TARGET = 0x004000, + D3D10_FORMAT_SUPPORT_BLENDABLE = 0x008000, + D3D10_FORMAT_SUPPORT_DEPTH_STENCIL = 0x010000, + D3D10_FORMAT_SUPPORT_CPU_LOCKABLE = 0x020000, + D3D10_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x040000, + D3D10_FORMAT_SUPPORT_DISPLAY = 0x080000, + 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 +} + +interface ID3D10Asynchronous : ID3D10DeviceChild { + extern(Windows) : + void Begin(); + void End(); + HRESULT GetData(void *pData, UINT DataSize, UINT GetDataFlags); + UINT GetDataSize(); +} + +enum D3D10_ASYNC_GETDATA_FLAG { + D3D10_ASYNC_GETDATA_DONOTFLUSH = 0x1 +} + +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 D3D10_QUERY_MISC_FLAG { + D3D10_QUERY_MISC_PREDICATEHINT = 0x01 +} + +struct D3D10_QUERY_DESC { + D3D10_QUERY Query; + UINT MiscFlags; +} + +interface ID3D10Query : ID3D10Asynchronous { + extern(Windows) : + void GetDesc(D3D10_QUERY_DESC *pDesc); +} + +interface ID3D10Predicate : ID3D10Query { } + +struct D3D10_QUERY_DATA_TIMESTAMP_DISJOINT { + UINT64 Frequency; + BOOL Disjoint; +} + +struct D3D10_QUERY_DATA_PIPELINE_STATISTICS { + UINT64 IAVertices; + UINT64 IAPrimitives; + UINT64 VSInvocations; + UINT64 GSInvocations; + UINT64 GSPrimitives; + UINT64 CInvocations; + UINT64 CPrimitives; + UINT64 PSInvocations; +} + +struct D3D10_QUERY_DATA_SO_STATISTICS { + UINT64 NumPrimitivesWritten; + UINT64 PrimitivesStorageNeeded; +} + +enum D3D10_COUNTER { + D3D10_COUNTER_GPU_IDLE = 0, + D3D10_COUNTER_VERTEX_PROCESSING = (D3D10_COUNTER_GPU_IDLE + 1), + D3D10_COUNTER_GEOMETRY_PROCESSING = (D3D10_COUNTER_VERTEX_PROCESSING + 1), + D3D10_COUNTER_PIXEL_PROCESSING = (D3D10_COUNTER_GEOMETRY_PROCESSING + 1), + D3D10_COUNTER_OTHER_GPU_PROCESSING = (D3D10_COUNTER_PIXEL_PROCESSING + 1), + D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION = (D3D10_COUNTER_OTHER_GPU_PROCESSING + 1), + D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION = (D3D10_COUNTER_HOST_ADAPTER_BANDWIDTH_UTILIZATION + 1), + D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION = (D3D10_COUNTER_LOCAL_VIDMEM_BANDWIDTH_UTILIZATION + 1), + D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION = (D3D10_COUNTER_VERTEX_THROUGHPUT_UTILIZATION + 1), + D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION = (D3D10_COUNTER_TRIANGLE_SETUP_THROUGHPUT_UTILIZATION + 1), + D3D10_COUNTER_VS_MEMORY_LIMITED = (D3D10_COUNTER_FILLRATE_THROUGHPUT_UTILIZATION + 1), + D3D10_COUNTER_VS_COMPUTATION_LIMITED = (D3D10_COUNTER_VS_MEMORY_LIMITED + 1), + D3D10_COUNTER_GS_MEMORY_LIMITED = (D3D10_COUNTER_VS_COMPUTATION_LIMITED + 1), + D3D10_COUNTER_GS_COMPUTATION_LIMITED = (D3D10_COUNTER_GS_MEMORY_LIMITED + 1), + D3D10_COUNTER_PS_MEMORY_LIMITED = (D3D10_COUNTER_GS_COMPUTATION_LIMITED + 1), + D3D10_COUNTER_PS_COMPUTATION_LIMITED = (D3D10_COUNTER_PS_MEMORY_LIMITED + 1), + D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE = (D3D10_COUNTER_PS_COMPUTATION_LIMITED + 1), + D3D10_COUNTER_TEXTURE_CACHE_HIT_RATE = (D3D10_COUNTER_POST_TRANSFORM_CACHE_HIT_RATE + 1), + D3D10_COUNTER_DEVICE_DEPENDENT_0 = 0x40000000 +} + +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 D3D10_COUNTER_DESC { + D3D10_COUNTER Counter; + UINT MiscFlags; +} + +struct D3D10_COUNTER_INFO { + D3D10_COUNTER LastDeviceDependentCounter; + UINT NumSimultaneousCounters; + UINT8 NumDetectableParallelUnits; +} + +interface ID3D10Counter : ID3D10Asynchronous { + extern(Windows) : + void GetDesc(D3D10_COUNTER_DESC *pDesc); +} + +interface ID3D10Device : IUnknown { + extern(Windows) : + void VSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppConstantBuffers); + void PSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderResourceView* ppShaderResourceViews); + void PSSetShader(ID3D10PixelShader pPixelShader); + void PSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* ppSamplers); + void VSSetShader(ID3D10VertexShader pVertexShader); + void DrawIndexed(UINT IndexCount, UINT StartIndexLocation, INT BaseVertexLocation); + void Draw(UINT VertexCount, UINT StartVertexLocation); + void PSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppConstantBuffers); + void IASetInputLayout(ID3D10InputLayout pInputLayout); + void IASetVertexBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppVertexBuffers, UINT* pStrides, UINT* pOffsets); + void IASetIndexBuffer(ID3D10Buffer pIndexBuffer, DXGI_FORMAT Format, UINT Offset); + void DrawIndexedInstanced(UINT IndexCountPerInstance, UINT InstanceCount, UINT StartIndexLocation, INT BaseVertexLocation, UINT StartInstanceLocation); + void DrawInstanced(UINT VertexCountPerInstance, UINT InstanceCount, UINT StartVertexLocation, UINT StartInstanceLocation); + void GSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppConstantBuffers); + void GSSetShader(ID3D10GeometryShader pShader); + void IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY Topology); + void VSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderResourceView* ppShaderResourceViews); + void VSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* ppSamplers); + void SetPredication(ID3D10Predicate pPredicate, BOOL PredicateValue); + void GSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderResourceView* ppShaderResourceViews); + void GSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* ppSamplers); + void OMSetRenderTargets(UINT NumViews, ID3D10RenderTargetView* ppRenderTargetViews, ID3D10DepthStencilView pDepthStencilView); + void OMSetBlendState(ID3D10BlendState pBlendState, FLOAT[4] BlendFactor, UINT SampleMask); + void OMSetDepthStencilState(ID3D10DepthStencilState pDepthStencilState, UINT StencilRef); + void SOSetTargets(UINT NumBuffers, ID3D10Buffer* ppSOTargets, UINT* pOffsets); + void DrawAuto(); + void RSSetState(ID3D10RasterizerState pRasterizerState); + void RSSetViewports(UINT NumViewports, D3D10_VIEWPORT* pViewports); + void RSSetScissorRects(UINT NumRects, D3D10_RECT* pRects); + void CopySubresourceRegion(ID3D10Resource pDstResource, UINT DstSubresource, UINT DstX, UINT DstY, UINT DstZ, ID3D10Resource pSrcResource, UINT SrcSubresource, D3D10_BOX* pSrcBox); + void CopyResource(ID3D10Resource pDstResource, ID3D10Resource pSrcResource); + void UpdateSubresource(ID3D10Resource pDstResource, UINT DstSubresource, D3D10_BOX* pDstBox, void* pSrcData, UINT SrcRowPitch, UINT SrcDepthPitch); + void ClearRenderTargetView(ID3D10RenderTargetView pRenderTargetView, FLOAT[4] ColorRGBA); + void ClearDepthStencilView(ID3D10DepthStencilView pDepthStencilView, UINT ClearFlags, FLOAT Depth, UINT8 Stencil); + void GenerateMips(ID3D10ShaderResourceView pShaderResourceView); + void ResolveSubresource(ID3D10Resource pDstResource, UINT DstSubresource, ID3D10Resource pSrcResource, UINT SrcSubresource, DXGI_FORMAT Format); + void VSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppConstantBuffers); + void PSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderResourceView* ppShaderResourceViews); + void PSGetShader(ID3D10PixelShader* ppPixelShader); + void PSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* ppSamplers); + void VSGetShader(ID3D10VertexShader* ppVertexShader); + void PSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppConstantBuffers); + void IAGetInputLayout(ID3D10InputLayout* ppInputLayout); + void IAGetVertexBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppVertexBuffers, UINT* pStrides, UINT* pOffsets); + void IAGetIndexBuffer(ID3D10Buffer* pIndexBuffer, DXGI_FORMAT* Format, UINT* Offset); + void GSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D10Buffer* ppConstantBuffers); + void GSGetShader(ID3D10GeometryShader* ppGeometryShader); + void IAGetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY* pTopology); + void VSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderResourceView* ppShaderResourceViews); + void VSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* ppSamplers); + void GetPredication(ID3D10Predicate* ppPredicate, BOOL* pPredicateValue); + void GSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D10ShaderResourceView* ppShaderResourceViews); + void GSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D10SamplerState* ppSamplers); + void OMGetRenderTargets(UINT NumViews, ID3D10RenderTargetView* ppRenderTargetViews, ID3D10DepthStencilView* ppDepthStencilView); + void OMGetBlendState(ID3D10BlendState* ppBlendState, FLOAT BlendFactor[ 4 ], UINT* pSampleMask); + void OMGetDepthStencilState(ID3D10DepthStencilState* ppDepthStencilState, UINT* pStencilRef); + void SOGetTargets(UINT NumBuffers, ID3D10Buffer* ppSOTargets, UINT* pOffsets); + void RSGetState(ID3D10RasterizerState* ppRasterizerState); + void RSGetViewports(UINT* NumViewports, D3D10_VIEWPORT* pViewports); + void RSGetScissorRects(UINT* NumRects, D3D10_RECT* pRects); + HRESULT GetDeviceRemovedReason(); + HRESULT SetExceptionMode(UINT RaiseFlags); + UINT GetExceptionMode(); + HRESULT GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData); + HRESULT SetPrivateData(REFGUID guid, UINT DataSize, void* pData); + HRESULT SetPrivateDataInterface(REFGUID guid, IUnknown pData); + void ClearState(); + void Flush(); + HRESULT CreateBuffer(D3D10_BUFFER_DESC* pDesc, D3D10_SUBRESOURCE_DATA* pInitialData, ID3D10Buffer* ppBuffer); + HRESULT CreateTexture1D(D3D10_TEXTURE1D_DESC* pDesc, D3D10_SUBRESOURCE_DATA* pInitialData, ID3D10Texture1D* ppTexture1D); + HRESULT CreateTexture2D(D3D10_TEXTURE2D_DESC* pDesc, D3D10_SUBRESOURCE_DATA* pInitialData, ID3D10Texture2D* ppTexture2D); + HRESULT CreateTexture3D(D3D10_TEXTURE3D_DESC* pDesc, D3D10_SUBRESOURCE_DATA* pInitialData, ID3D10Texture3D* ppTexture3D); + HRESULT CreateShaderResourceView(ID3D10Resource pResource, D3D10_SHADER_RESOURCE_VIEW_DESC* pDesc, ID3D10ShaderResourceView* ppSRView); + HRESULT CreateRenderTargetView(ID3D10Resource pResource, D3D10_RENDER_TARGET_VIEW_DESC* pDesc, ID3D10RenderTargetView* ppRTView); + HRESULT CreateDepthStencilView(ID3D10Resource pResource, D3D10_DEPTH_STENCIL_VIEW_DESC* pDesc, ID3D10DepthStencilView* ppDepthStencilView); + HRESULT CreateInputLayout(D3D10_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements, void* pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, ID3D10InputLayout* ppInputLayout); + HRESULT CreateVertexShader(void* pShaderBytecode, SIZE_T BytecodeLength, ID3D10VertexShader* ppVertexShader); + HRESULT CreateGeometryShader(void* pShaderBytecode, SIZE_T BytecodeLength, ID3D10GeometryShader* ppGeometryShader); + HRESULT CreateGeometryShaderWithStreamOutput(void* pShaderBytecode, SIZE_T BytecodeLength, D3D10_SO_DECLARATION_ENTRY* pSODeclaration, UINT NumEntries, UINT OutputStreamStride, ID3D10GeometryShader* ppGeometryShader); + HRESULT CreatePixelShader(void* pShaderBytecode, SIZE_T BytecodeLength, ID3D10PixelShader* ppPixelShader); + HRESULT CreateBlendState(D3D10_BLEND_DESC* pBlendStateDesc, ID3D10BlendState* ppBlendState); + HRESULT CreateDepthStencilState(D3D10_DEPTH_STENCIL_DESC* pDepthStencilDesc, ID3D10DepthStencilState* ppDepthStencilState); + HRESULT CreateRasterizerState(D3D10_RASTERIZER_DESC* pRasterizerDesc, ID3D10RasterizerState* ppRasterizerState); + HRESULT CreateSamplerState(D3D10_SAMPLER_DESC* pSamplerDesc, ID3D10SamplerState* ppSamplerState); + HRESULT CreateQuery(D3D10_QUERY_DESC* pQueryDesc, ID3D10Query* ppQuery); + HRESULT CreatePredicate(D3D10_QUERY_DESC* pPredicateDesc, ID3D10Predicate* ppPredicate); + HRESULT CreateCounter(D3D10_COUNTER_DESC* pCounterDesc, ID3D10Counter* ppCounter); + HRESULT CheckFormatSupport(DXGI_FORMAT Format, UINT* pFormatSupport); + HRESULT CheckMultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, UINT* pNumQualityLevels); + void CheckCounterInfo(D3D10_COUNTER_INFO* pCounterInfo); + HRESULT CheckCounter(D3D10_COUNTER_DESC* pDesc, D3D10_COUNTER_TYPE* pType, UINT* pActiveCounters, LPSTR szName, UINT* pNameLength, LPSTR szUnits, UINT* pUnitsLength, LPSTR szDescription, UINT* pDescriptionLength); + UINT GetCreationFlags(); + HRESULT OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, void** ppResource); + void SetTextFilterSize(UINT Width, UINT Height); + void GetTextFilterSize(UINT* pWidth, UINT* pHeight); +} + +interface ID3D10Multithread : IUnknown { + extern(Windows) : + void Enter(); + void Leave(); + BOOL SetMultithreadProtected(BOOL bMTProtect); + BOOL GetMultithreadProtected(); +} + +enum D3D10_CREATE_DEVICE_FLAG { + D3D10_CREATE_DEVICE_SINGLETHREADED = 0x01, + D3D10_CREATE_DEVICE_DEBUG = 0x02, + D3D10_CREATE_DEVICE_SWITCH_TO_REF = 0x04, + D3D10_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x08 +} + +const D3D10_SDK_VERSION = 29; + +extern(C) const GUID IID_ID3D10DeviceChild = {0x9B7E4C00, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10DepthStencilState = {0x2B4B1CC8, 0xA4AD, 0x41f8, [0x83, 0x22, 0xCA, 0x86, 0xFC, 0x3E, 0xC6, 0x75]}; +extern(C) const GUID IID_ID3D10BlendState = {0xEDAD8D19, 0x8A35, 0x4d6d, [0x85, 0x66, 0x2E, 0xA2, 0x76, 0xCD, 0xE1, 0x61]}; +extern(C) const GUID IID_ID3D10RasterizerState = {0xA2A07292, 0x89AF, 0x4345, [0xBE, 0x2E, 0xC5, 0x3D, 0x9F, 0xBB, 0x6E, 0x9F]}; +extern(C) const GUID IID_ID3D10Resource = {0x9B7E4C01, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Buffer = {0x9B7E4C02, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Texture1D = {0x9B7E4C03, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Texture2D = {0x9B7E4C04, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Texture3D = {0x9B7E4C05, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10View = {0xC902B03F, 0x60A7, 0x49BA, [0x99, 0x36, 0x2A, 0x3A, 0xB3, 0x7A, 0x7E, 0x33]}; +extern(C) const GUID IID_ID3D10ShaderResourceView = {0x9B7E4C07, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10RenderTargetView = {0x9B7E4C08, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10DepthStencilView = {0x9B7E4C09, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10VertexShader = {0x9B7E4C0A, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10GeometryShader = {0x6316BE88, 0x54CD, 0x4040, [0xAB, 0x44, 0x20, 0x46, 0x1B, 0xC8, 0x1F, 0x68]}; +extern(C) const GUID IID_ID3D10PixelShader = {0x4968B601, 0x9D00, 0x4cde, [0x83, 0x46, 0x8E, 0x7F, 0x67, 0x58, 0x19, 0xB6]}; +extern(C) const GUID IID_ID3D10InputLayout = {0x9B7E4C0B, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10SamplerState = {0x9B7E4C0C, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Asynchronous = {0x9B7E4C0D, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Query = {0x9B7E4C0E, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Predicate = {0x9B7E4C10, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Counter = {0x9B7E4C11, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Device = {0x9B7E4C0F, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +extern(C) const GUID IID_ID3D10Multithread = {0x9B7E4E00, 0x342C, 0x4106, [0xA1, 0x9F, 0x4F, 0x27, 0x04, 0xF6, 0x89, 0xF0]}; +