root/trunk/win32/directx/d3d10.d

/***********************************************************************\
*                                 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;

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]};

public import win32.directx.d3d10shader;
public import win32.directx.d3d10effect;