Artifact 440959a663efe1fe4fa5cbc9732e4e8f70edcf85

• File src/win32/directx/d3d10.d
  • 2015-05-05 06:49:05 - part of checkin [9b639cf2d6] on branch trunk - Working version for update to 2.067.

    The problem was __gshared. Replacing it with TLS fixed the issue. Remaining problem is that "hack.d"'s CloseHandle hack is not working anymore.

    (user: kinaba) [annotate]

/***********************************************************************\
*                                 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[ 4 ] BlendFactor, 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;