0001 Add 2 idl files for d3d10

Kovács András andras at csevego.net
Mon Jul 9 05:52:43 CDT 2007


Hi,

0001-Add-2-idl-files-for-d3d10.txt
-- 
----------------------------
Kovács András (andras)
NetClub Vezető Rendszergazda
Lamarr
csevego.net
andras at csevego.net
----------------------------
-------------- next part --------------
From 342ccc371275d50e72159832e6d720d751f983e5 Mon Sep 17 00:00:00 2001
From: =?utf-8?q?Andr=C3=A1s_Kov=C3=A1cs?= <andras at debian.sth.sze.hu>
Date: Mon, 9 Jul 2007 12:50:37 +0200
Subject: [PATCH] Add 2 idl files for d3d10

---
 include/Makefile.in  |    2 +
 include/d3d10.idl    | 1385 ++++++++++++++++++++++++++++++++++++++++++++++++++
 include/dxgitype.idl |  116 +++++
 3 files changed, 1503 insertions(+), 0 deletions(-)

diff --git a/include/Makefile.in b/include/Makefile.in
index 4526036..4ff26a5 100644
--- a/include/Makefile.in
+++ b/include/Makefile.in
@@ -11,6 +11,8 @@ IDL_H_SRCS = \
 	austream.idl \
 	comcat.idl \
 	control.idl \
+	d3d10.idl \
+	dxgitype.idl \
 	ddstream.idl \
 	dispex.idl \
 	docobj.idl \
diff --git a/include/d3d10.idl b/include/d3d10.idl
new file mode 100644
index 0000000..84f5eee
--- /dev/null
+++ b/include/d3d10.idl
@@ -0,0 +1,1385 @@
+/*
+ * Copyright 2007 Andras Kovacs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+import "unknwn.idl";
+import "dxgitype.idl";
+
+#define D3D10_16BIT_INDEX_STRIP_CUT_VALUE                                              ( 0xffff )
+#define D3D10_32BIT_INDEX_STRIP_CUT_VALUE                                              ( 0xffffffff )
+#define D3D10_8BIT_INDEX_STRIP_CUT_VALUE                                               ( 0xff )
+#define D3D10_ARRAY_AXIS_ADDRESS_RANGE_BIT_COUNT                                       ( 9 )
+#define D3D10_CLIP_OR_CULL_DISTANCE_COUNT                                              ( 8 )
+#define D3D10_CLIP_OR_CULL_DISTANCE_ELEMENT_COUNT                                      ( 2 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT                              ( 14 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENTS                                  ( 4 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_COMPONENT_BIT_COUNT                         ( 32 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_HW_SLOT_COUNT                               ( 15 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COMPONENTS                         ( 4 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT                              ( 15 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READS_PER_INST                     ( 1 )
+#define D3D10_COMMONSHADER_CONSTANT_BUFFER_REGISTER_READ_PORTS                         ( 1 )
+#define D3D10_COMMONSHADER_FLOWCONTROL_NESTING_LIMIT                                   ( 64 )
+#define D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COMPONENTS               ( 4 )
+#define D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_COUNT                    ( 1 )
+#define D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READS_PER_INST           ( 1 )
+#define D3D10_COMMONSHADER_IMMEDIATE_CONSTANT_BUFFER_REGISTER_READ_PORTS               ( 1 )
+#define D3D10_COMMONSHADER_IMMEDIATE_VALUE_COMPONENT_BIT_COUNT                         ( 32 )
+#define D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COMPONENTS                          ( 1 )
+#define D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_COUNT                               ( 128 )
+#define D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READS_PER_INST                      ( 1 )
+#define D3D10_COMMONSHADER_INPUT_RESOURCE_REGISTER_READ_PORTS                          ( 1 )
+#define D3D10_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT                                   ( 128 )
+#define D3D10_COMMONSHADER_SAMPLER_REGISTER_COMPONENTS                                 ( 1 )
+#define D3D10_COMMONSHADER_SAMPLER_REGISTER_COUNT                                      ( 16 )
+#define D3D10_COMMONSHADER_SAMPLER_REGISTER_READS_PER_INST                             ( 1 )
+#define D3D10_COMMONSHADER_SAMPLER_REGISTER_READ_PORTS                                 ( 1 )
+#define D3D10_COMMONSHADER_SAMPLER_SLOT_COUNT                                          ( 16 )
+#define D3D10_COMMONSHADER_SUBROUTINE_NESTING_LIMIT                                    ( 32 )
+#define D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENTS                                    ( 4 )
+#define D3D10_COMMONSHADER_TEMP_REGISTER_COMPONENT_BIT_COUNT                           ( 32 )
+#define D3D10_COMMONSHADER_TEMP_REGISTER_COUNT                                         ( 4096 )
+#define D3D10_COMMONSHADER_TEMP_REGISTER_READS_PER_INST                                ( 3 )
+#define D3D10_COMMONSHADER_TEMP_REGISTER_READ_PORTS                                    ( 3 )
+#define D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MAX                                ( 10 )
+#define D3D10_COMMONSHADER_TEXCOORD_RANGE_REDUCTION_MIN                                ( -10 )
+#define D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_NEGATIVE                                   ( -8 )
+#define D3D10_COMMONSHADER_TEXEL_OFFSET_MAX_POSITIVE                                   ( 7 )
+#define D3D10_DEFAULT_BLEND_FACTOR_ALPHA                                               ( 1.0f )
+#define D3D10_DEFAULT_BLEND_FACTOR_BLUE                                                ( 1.0f )
+#define D3D10_DEFAULT_BLEND_FACTOR_GREEN                                               ( 1.0f )
+#define D3D10_DEFAULT_BLEND_FACTOR_RED                                                 ( 1.0f )
+#define D3D10_DEFAULT_BORDER_COLOR_COMPONENT                                           ( 0.0f )
+#define D3D10_DEFAULT_DEPTH_BIAS                                                       ( 0 )
+#define D3D10_DEFAULT_DEPTH_BIAS_CLAMP                                                 ( 0.0f )
+#define D3D10_DEFAULT_MAX_ANISOTROPY                                                   ( 16.0f )
+#define D3D10_DEFAULT_MIP_LOD_BIAS                                                     ( 0.0f )
+#define D3D10_DEFAULT_RENDER_TARGET_ARRAY_INDEX                                        ( 0 )
+#define D3D10_DEFAULT_SAMPLE_MASK                                                      ( 0xffffffff )
+#define D3D10_DEFAULT_SCISSOR_ENDX                                                     ( 0 )
+#define D3D10_DEFAULT_SCISSOR_ENDY                                                     ( 0 )
+#define D3D10_DEFAULT_SCISSOR_STARTX                                                   ( 0 )
+#define D3D10_DEFAULT_SCISSOR_STARTY                                                   ( 0 )
+#define D3D10_DEFAULT_SLOPE_SCALED_DEPTH_BIAS                                          ( 0.0f )
+#define D3D10_DEFAULT_STENCIL_READ_MASK                                                ( 0xff )
+#define D3D10_DEFAULT_STENCIL_REFERENCE                                                ( 0 )
+#define D3D10_DEFAULT_STENCIL_WRITE_MASK                                               ( 0xff )
+#define D3D10_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX                                   ( 0 )
+#define D3D10_DEFAULT_VIEWPORT_HEIGHT                                                  ( 0 )
+#define D3D10_DEFAULT_VIEWPORT_MAX_DEPTH                                               ( 0.0f )
+#define D3D10_DEFAULT_VIEWPORT_MIN_DEPTH                                               ( 0.0f )
+#define D3D10_DEFAULT_VIEWPORT_TOPLEFTX                                                ( 0 )
+#define D3D10_DEFAULT_VIEWPORT_TOPLEFTY                                                ( 0 )
+#define D3D10_DEFAULT_VIEWPORT_WIDTH                                                   ( 0 )
+#define D3D10_FLOAT16_FUSED_TOLERANCE_IN_ULP                                           ( 0.6 )
+#define D3D10_FLOAT32_MAX                                                              ( 3.402823466e+38f )
+#define D3D10_FLOAT32_TO_INTEGER_TOLERANCE_IN_ULP                                      ( 0.6f )
+#define D3D10_FLOAT_TO_SRGB_EXPONENT_DENOMINATOR                                       ( 2.4f )
+#define D3D10_FLOAT_TO_SRGB_EXPONENT_NUMERATOR                                         ( 1.0f )
+#define D3D10_FLOAT_TO_SRGB_OFFSET                                                     ( 0.055f )
+#define D3D10_FLOAT_TO_SRGB_SCALE_1                                                    ( 12.92f )
+#define D3D10_FLOAT_TO_SRGB_SCALE_2                                                    ( 1.055f )
+#define D3D10_FLOAT_TO_SRGB_THRESHOLD                                                  ( 0.0031308f )
+#define D3D10_FTOI_INSTRUCTION_MAX_INPUT                                               ( 2147483647.999f )
+#define D3D10_FTOI_INSTRUCTION_MIN_INPUT                                               ( -2147483648.999f )
+#define D3D10_FTOU_INSTRUCTION_MAX_INPUT                                               ( 4294967295.999f )
+#define D3D10_FTOU_INSTRUCTION_MIN_INPUT                                               ( 0.0f )
+#define D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENTS                                  ( 1 )
+#define D3D10_GS_INPUT_PRIM_CONST_REGISTER_COMPONENT_BIT_COUNT                         ( 32 )
+#define D3D10_GS_INPUT_PRIM_CONST_REGISTER_COUNT                                       ( 1 )
+#define D3D10_GS_INPUT_PRIM_CONST_REGISTER_READS_PER_INST                              ( 2 )
+#define D3D10_GS_INPUT_PRIM_CONST_REGISTER_READ_PORTS                                  ( 1 )
+#define D3D10_GS_INPUT_REGISTER_COMPONENTS                                             ( 4 )
+#define D3D10_GS_INPUT_REGISTER_COMPONENT_BIT_COUNT                                    ( 32 )
+#define D3D10_GS_INPUT_REGISTER_COUNT                                                  ( 16 )
+#define D3D10_GS_INPUT_REGISTER_READS_PER_INST                                         ( 2 )
+#define D3D10_GS_INPUT_REGISTER_READ_PORTS                                             ( 1 )
+#define D3D10_GS_INPUT_REGISTER_VERTICES                                               ( 6 )
+#define D3D10_GS_OUTPUT_ELEMENTS                                                       ( 32 )
+#define D3D10_GS_OUTPUT_REGISTER_COMPONENTS                                            ( 4 )
+#define D3D10_GS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT                                   ( 32 )
+#define D3D10_GS_OUTPUT_REGISTER_COUNT                                                 ( 32 )
+#define D3D10_IA_DEFAULT_INDEX_BUFFER_OFFSET_IN_BYTES                                  ( 0 )
+#define D3D10_IA_DEFAULT_PRIMITIVE_TOPOLOGY                                            ( 0 )
+#define D3D10_IA_DEFAULT_VERTEX_BUFFER_OFFSET_IN_BYTES                                 ( 0 )
+#define D3D10_IA_INDEX_INPUT_RESOURCE_SLOT_COUNT                                       ( 1 )
+#define D3D10_IA_INSTANCE_ID_BIT_COUNT                                                 ( 32 )
+#define D3D10_IA_INTEGER_ARITHMETIC_BIT_COUNT                                          ( 32 )
+#define D3D10_IA_PRIMITIVE_ID_BIT_COUNT                                                ( 32 )
+#define D3D10_IA_VERTEX_ID_BIT_COUNT                                                   ( 32 )
+#define D3D10_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT                                      ( 16 )
+#define D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENTS_COMPONENTS                            ( 64 )
+#define D3D10_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT                                  ( 16 )
+#define D3D10_INTEGER_DIVIDE_BY_ZERO_QUOTIENT                                          ( 0xffffffff )
+#define D3D10_INTEGER_DIVIDE_BY_ZERO_REMAINDER                                         ( 0xffffffff )
+#define D3D10_LINEAR_GAMMA                                                             ( 1.0f )
+#define D3D10_MAX_BORDER_COLOR_COMPONENT                                               ( 1.0f )
+#define D3D10_MAX_DEPTH                                                                ( 1.0f )
+#define D3D10_MAX_MAXANISOTROPY                                                        ( 16 )
+#define D3D10_MAX_MULTISAMPLE_SAMPLE_COUNT                                             ( 32 )
+#define D3D10_MAX_POSITION_VALUE                                                       ( 3.402823466e+34f )
+#define D3D10_MAX_TEXTURE_DIMENSION_2_TO_EXP                                           ( 17 )
+#define D3D10_MIN_BORDER_COLOR_COMPONENT                                               ( 0.0f )
+#define D3D10_MIN_DEPTH                                                                ( 0.0f )
+#define D3D10_MIN_MAXANISOTROPY                                                        ( 0 )
+#define D3D10_MIP_LOD_BIAS_MAX                                                         ( 15.99f )
+#define D3D10_MIP_LOD_BIAS_MIN                                                         ( -16.0f )
+#define D3D10_MIP_LOD_FRACTIONAL_BIT_COUNT                                             ( 6 )
+#define D3D10_MIP_LOD_RANGE_BIT_COUNT                                                  ( 8 )
+#define D3D10_MULTISAMPLE_ANTIALIAS_LINE_WIDTH                                         ( 1.4f )
+#define D3D10_NONSAMPLE_FETCH_OUT_OF_RANGE_ACCESS_RESULT                               ( 0 )
+#define D3D10_PIXEL_ADDRESS_RANGE_BIT_COUNT                                            ( 13 )
+#define D3D10_PRE_SCISSOR_PIXEL_ADDRESS_RANGE_BIT_COUNT                                ( 15 )
+#define D3D10_PS_FRONTFACING_DEFAULT_VALUE                                             ( 0xffffffff )
+#define D3D10_PS_FRONTFACING_FALSE_VALUE                                               ( 0 )
+#define D3D10_PS_FRONTFACING_TRUE_VALUE                                                ( 0xffffffff )
+#define D3D10_PS_INPUT_REGISTER_COMPONENTS                                             ( 4 )
+#define D3D10_PS_INPUT_REGISTER_COMPONENT_BIT_COUNT                                    ( 32 )
+#define D3D10_PS_INPUT_REGISTER_COUNT                                                  ( 32 )
+#define D3D10_PS_INPUT_REGISTER_READS_PER_INST                                         ( 2 )
+#define D3D10_PS_INPUT_REGISTER_READ_PORTS                                             ( 1 )
+#define D3D10_PS_LEGACY_PIXEL_CENTER_FRACTIONAL_COMPONENT                              ( 0.0f )
+#define D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENTS                                      ( 1 )
+#define D3D10_PS_OUTPUT_DEPTH_REGISTER_COMPONENT_BIT_COUNT                             ( 32 )
+#define D3D10_PS_OUTPUT_DEPTH_REGISTER_COUNT                                           ( 1 )
+#define D3D10_PS_OUTPUT_REGISTER_COMPONENTS                                            ( 4 )
+#define D3D10_PS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT                                   ( 32 )
+#define D3D10_PS_OUTPUT_REGISTER_COUNT                                                 ( 8 )
+#define D3D10_PS_PIXEL_CENTER_FRACTIONAL_COMPONENT                                     ( 0.5f )
+#define D3D10_REQ_BLEND_OBJECT_COUNT_PER_CONTEXT                                       ( 4096 )
+#define D3D10_REQ_BUFFER_RESOURCE_TEXEL_COUNT_2_TO_EXP                                 ( 27 )
+#define D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT                                        ( 4096 )
+#define D3D10_REQ_DEPTH_STENCIL_OBJECT_COUNT_PER_CONTEXT                               ( 4096 )
+#define D3D10_REQ_DRAWINDEXED_INDEX_COUNT_2_TO_EXP                                     ( 32 )
+#define D3D10_REQ_DRAW_VERTEX_COUNT_2_TO_EXP                                           ( 32 )
+#define D3D10_REQ_FILTERING_HW_ADDRESSABLE_RESOURCE_DIMENSION                          ( 8192 )
+#define D3D10_REQ_GS_INVOCATION_32BIT_OUTPUT_COMPONENT_LIMIT                           ( 1024 )
+#define D3D10_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT                              ( 4096 )
+#define D3D10_REQ_MAXANISOTROPY                                                        ( 16 )
+#define D3D10_REQ_MIP_LEVELS                                                           ( 14 )
+#define D3D10_REQ_MULTI_ELEMENT_STRUCTURE_SIZE_IN_BYTES                                ( 2048 )
+#define D3D10_REQ_RASTERIZER_OBJECT_COUNT_PER_CONTEXT                                  ( 4096 )
+#define D3D10_REQ_RENDER_TO_BUFFER_WINDOW_WIDTH                                        ( 8192 )
+#define D3D10_REQ_RESOURCE_SIZE_IN_MEGABYTES                                           ( 128 )
+#define D3D10_REQ_RESOURCE_VIEW_COUNT_PER_CONTEXT_2_TO_EXP                             ( 20 )
+#define D3D10_REQ_SAMPLER_OBJECT_COUNT_PER_CONTEXT                                     ( 4096 )
+#define D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION                                       ( 512 )
+#define D3D10_REQ_TEXTURE1D_U_DIMENSION                                                ( 8192 )
+#define D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION                                       ( 512 )
+#define D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION                                           ( 8192 )
+#define D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION                                         ( 2048 )
+#define D3D10_REQ_TEXTURECUBE_DIMENSION                                                ( 8192 )
+#define D3D10_RESINFO_INSTRUCTION_MISSING_COMPONENT_RETVAL                             ( 0 )
+#define D3D10_SHADER_MAJOR_VERSION                                                     ( 4 )
+#define D3D10_SHADER_MINOR_VERSION                                                     ( 0 )
+#define D3D10_SHIFT_INSTRUCTION_PAD_VALUE                                              ( 0 )
+#define D3D10_SHIFT_INSTRUCTION_SHIFT_VALUE_BIT_COUNT                                  ( 5 )
+#define D3D10_SIMULTANEOUS_RENDER_TARGET_COUNT                                         ( 8 )
+#define D3D10_SO_BUFFER_MAX_STRIDE_IN_BYTES                                            ( 2048 )
+#define D3D10_SO_BUFFER_MAX_WRITE_WINDOW_IN_BYTES                                      ( 256 )
+#define D3D10_SO_BUFFER_SLOT_COUNT                                                     ( 4 )
+#define D3D10_SO_DDI_REGISTER_INDEX_DENOTING_GAP                                       ( 0xffffffff )
+#define D3D10_SO_MULTIPLE_BUFFER_ELEMENTS_PER_BUFFER                                   ( 1 )
+#define D3D10_SO_SINGLE_BUFFER_COMPONENT_LIMIT                                         ( 64 )
+#define D3D10_SRGB_GAMMA                                                               ( 2.2f )
+#define D3D10_SRGB_TO_FLOAT_DENOMINATOR_1                                              ( 12.92f )
+#define D3D10_SRGB_TO_FLOAT_DENOMINATOR_2                                              ( 1.055f )
+#define D3D10_SRGB_TO_FLOAT_EXPONENT                                                   ( 2.4f )
+#define D3D10_SRGB_TO_FLOAT_OFFSET                                                     ( 0.055f )
+#define D3D10_SRGB_TO_FLOAT_THRESHOLD                                                  ( 0.04045f )
+#define D3D10_SRGB_TO_FLOAT_TOLERANCE_IN_ULP                                           ( 0.5f )
+#define D3D10_STANDARD_COMPONENT_BIT_COUNT                                             ( 32 )
+#define D3D10_STANDARD_COMPONENT_BIT_COUNT_DOUBLED                                     ( 64 )
+#define D3D10_STANDARD_MAXIMUM_ELEMENT_ALIGNMENT_BYTE_MULTIPLE                         ( 4 )
+#define D3D10_STANDARD_PIXEL_COMPONENT_COUNT                                           ( 128 )
+#define D3D10_STANDARD_PIXEL_ELEMENT_COUNT                                             ( 32 )
+#define D3D10_STANDARD_VECTOR_SIZE                                                     ( 4 )
+#define D3D10_STANDARD_VERTEX_ELEMENT_COUNT                                            ( 16 )
+#define D3D10_STANDARD_VERTEX_TOTAL_COMPONENT_COUNT                                    ( 64 )
+#define D3D10_SUBPIXEL_FRACTIONAL_BIT_COUNT                                            ( 8 )
+#define D3D10_SUBTEXEL_FRACTIONAL_BIT_COUNT                                            ( 6 )
+#define D3D10_TEXEL_ADDRESS_RANGE_BIT_COUNT                                            ( 18 )
+#define D3D10_UNBOUND_MEMORY_ACCESS_RESULT                                             ( 0 )
+#define D3D10_VIEWPORT_AND_SCISSORRECT_MAX_INDEX                                       ( 15 )
+#define D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE                       ( 16 )
+#define D3D10_VIEWPORT_BOUNDS_MAX                                                      ( 16383 )
+#define D3D10_VIEWPORT_BOUNDS_MIN                                                      ( -16384 )
+#define D3D10_VS_INPUT_REGISTER_COMPONENTS                                             ( 4 )
+#define D3D10_VS_INPUT_REGISTER_COMPONENT_BIT_COUNT                                    ( 32 )
+#define D3D10_VS_INPUT_REGISTER_COUNT                                                  ( 16 )
+#define D3D10_VS_INPUT_REGISTER_READS_PER_INST                                         ( 2 )
+#define D3D10_VS_INPUT_REGISTER_READ_PORTS                                             ( 1 )
+#define D3D10_VS_OUTPUT_REGISTER_COMPONENTS                                            ( 4 )
+#define D3D10_VS_OUTPUT_REGISTER_COMPONENT_BIT_COUNT                                   ( 32 )
+#define D3D10_VS_OUTPUT_REGISTER_COUNT                                                 ( 16 )
+#define D3D10_WHQL_CONTEXT_COUNT_FOR_RESOURCE_LIMIT                                    ( 10 )
+#define D3D10_WHQL_DRAWINDEXED_INDEX_COUNT_2_TO_EXP                                    ( 25 )
+#defineD3D10_WHQL_DRAW_VERTEX_COUNT_2_TO_EXP                                           ( 25 )
+
+typedef 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,
+} D3D10_BLEND;
+
+typedef enum D3D10_BLEND_OP {
+    D3D10_BLEND_OP_ADD          = 1,
+    D3D10_BLEND_OP_SUBTRACT     = 2,
+    D3D10_BLEND_OP_REV_SUBTRACT = 3,
+    D3D10_BLEND_OP_MIN          = 4,
+    D3D10_BLEND_OP_MAX          = 5,
+} D3D10_BLEND_OP;
+
+typedef struct D3D10_BLEND_DESC {
+    BOOL AlphaToCoverageEnable;
+    BOOL BlendEnable[8];
+    D3D10_BLEND SrcBlend;
+    D3D10_BLEND DestBlend;
+    D3D10_BLEND_OP BlendOp;
+    D3D10_BLEND SrcBlendAlpha;
+    D3D10_BLEND DestBlendAlpha;
+    D3D10_BLEND_OP BlendOpAlpha;
+    UINT8 RenderTargetWriteMask[8];
+} D3D10_BLEND_DESC;
+
+typedef enum D3D10_DEPTH_WRITE_MASK {
+    D3D10_DEPTH_WRITE_MASK_ZERO = 0,
+    D3D10_DEPTH_WRITE_MASK_ALL  = 1,
+} D3D10_DEPTH_WRITE_MASK;
+
+typedef enum D3D10_COMPARISON_FUNC {
+    D3D10_COMPARISON_NEVER           = 1,
+    D3D10_COMPARISON_LESS            = 2,
+    D3D10_COMPARISON_EQUAL           = 3,
+    D3D10_COMPARISON_LESS_EQUAL      = 4,
+    D3D10_COMPARISON_GREATER         = 5,
+    D3D10_COMPARISON_NOT_EQUAL       = 6,
+    D3D10_COMPARISON_GREATER_EQUAL   = 7,
+    D3D10_COMPARISON_ALWAYS          = 8,
+} D3D10_COMPARISON_FUNC;
+
+typedef enum D3D10_STENCIL_OP {
+    D3D10_STENCIL_OP_KEEP       = 1,
+    D3D10_STENCIL_OP_ZERO       = 2,
+    D3D10_STENCIL_OP_REPLACE    = 3,
+    D3D10_STENCIL_OP_INCR_SAT   = 4,
+    D3D10_STENCIL_OP_DECR_SAT   = 5,
+    D3D10_STENCIL_OP_INVERT     = 6,
+    D3D10_STENCIL_OP_INCR       = 7,
+    D3D10_STENCIL_OP_DECR       = 8,
+} D3D10_STENCIL_OP;
+
+typedef struct D3D10_DEPTH_STENCILOP_DESC {
+    D3D10_STENCIL_OP StencilFailOp;
+    D3D10_STENCIL_OP StencilDepthFailOp;
+    D3D10_STENCIL_OP StencilPassOp;
+    D3D10_COMPARISON_FUNC StencilFunc;
+} D3D10_DEPTH_STENCILOP_DESC;
+
+typedef 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;
+} D3D10_DEPTH_STENCIL_DESC;
+
+typedef enum D3D10_FILL_MODE {
+    D3D10_FILL_WIREFRAME = 2,
+    D3D10_FILL_SOLID     = 3,
+} D3D10_FILL_MODE;
+
+typedef enum D3D10_CULL_MODE {
+    D3D10_CULL_NONE     = 1,
+    D3D10_CULL_FRONT    = 2,
+    D3D10_CULL_BACK     = 3,
+} D3D10_CULL_MODE;
+
+typedef 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;
+} D3D10_RASTERIZER_DESC;
+
+typedef enum D3D10_FILTER {
+    D3D10_FILTER_MIN_MAG_MIP_POINT                              = 0,
+    D3D10_FILTER_MIN_MAG_POINT_MIP_LINEAR                       = 0x1,
+    D3D10_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT                 = 0x4,
+    D3D10_FILTER_MIN_POINT_MAG_MIP_LINEAR                       = 0x5,
+    D3D10_FILTER_MIN_LINEAR_MAG_MIP_POINT                       = 0x10,
+    D3D10_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR                = 0x11,
+    D3D10_FILTER_MIN_MAG_LINEAR_MIP_POINT                       = 0x14,
+    D3D10_FILTER_MIN_MAG_MIP_LINEAR                             = 0x15,
+    D3D10_FILTER_ANISOTROPIC                                    = 0x55,
+    D3D10_FILTER_COMPARISON_MIN_MAG_MIP_POINT                   = 0x80,
+    D3D10_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR            = 0x81,
+    D3D10_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT      = 0x84,
+    D3D10_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR            = 0x85,
+    D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT            = 0x90,
+    D3D10_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR     = 0x91,
+    D3D10_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT            = 0x94,
+    D3D10_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR                  = 0x95,
+    D3D10_FILTER_COMPARISON_ANISOTROPIC                         = 0xd5,
+    D3D10_FILTER_TEXT_1BIT                                      = 0x80000000,
+} D3D10_FILTER;
+
+typedef enum D3D10_TEXTURE_ADDRESS_MODE {
+    D3D10_TEXTURE_ADDRESS_WRAP          = 1,
+    D3D10_TEXTURE_ADDRESS_MIRROR        = 2,
+    D3D10_TEXTURE_ADDRESS_CLAMP         = 3,
+    D3D10_TEXTURE_ADDRESS_BORDER        = 4,
+    D3D10_TEXTURE_ADDRESS_MIRROR_ONCE   = 5,
+} D3D10_TEXTURE_ADDRESS_MODE;
+
+typedef 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 BorderColor[4];
+    FLOAT MinLOD;
+    FLOAT MaxLOD;
+} D3D10_SAMPLER_DESC;
+
+typedef 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,
+} D3D10_COUNTER;
+
+typedef struct D3D10_COUNTER_DESC {
+    D3D10_COUNTER Counter;
+    UINT MiscFlags;
+} D3D10_COUNTER_DESC;
+
+typedef 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 ),
+} D3D10_COUNTER_TYPE;
+
+typedef struct D3D10_COUNTER_INFO {
+    D3D10_COUNTER LastDeviceDependentCounter;
+    UINT NumSimultaneousCounters;
+    UINT8 NumDetectableParallelUnits;
+} D3D10_COUNTER_INFO;
+
+typedef enum D3D10_RESOURCE_DIMENSION {
+    D3D10_RESOURCE_DIMENSION_UNKNOWN   = 0,
+    D3D10_RESOURCE_DIMENSION_BUFFER    = 1,
+    D3D10_RESOURCE_DIMENSION_TEXTURE1D = 2,
+    D3D10_RESOURCE_DIMENSION_TEXTURE2D = 3,
+    D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4,
+} D3D10_RESOURCE_DIMENSION;
+
+typedef enum D3D10_USAGE {
+    D3D10_USAGE_DEFAULT   = 0,
+    D3D10_USAGE_IMMUTABLE = 1,
+    D3D10_USAGE_DYNAMIC   = 2,
+    D3D10_USAGE_STAGING   = 3,
+} D3D10_USAGE;
+
+typedef struct D3D10_BUFFER_DESC {
+    UINT ByteWidth;
+    D3D10_USAGE Usage;
+    UINT BindFlags;
+    UINT CPUAccessFlags;
+    UINT MiscFlags;
+} D3D10_BUFFER_DESC;
+
+typedef enum D3D10_MAP {
+    D3D10_MAP_READ               = 1,
+    D3D10_MAP_WRITE              = 2,
+    D3D10_MAP_READ_WRITE         = 3,
+    D3D10_MAP_WRITE_DISCARD      = 4,
+    D3D10_MAP_WRITE_NO_OVERWRITE = 5,
+} D3D10_MAP;
+
+typedef struct D3D10_TEXTURE1D_DESC {
+    UINT Width;
+    UINT MipLevels;
+    UINT ArraySize;
+    DXGI_FORMAT Format;
+    D3D10_USAGE Usage;
+    UINT BindFlags;
+    UINT CPUAccessFlags;
+    UINT MiscFlags;
+} D3D10_TEXTURE1D_DESC;
+
+typedef 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;
+} D3D10_TEXTURE2D_DESC;
+
+typedef struct D3D10_TEXTURE3D_DESC {
+    UINT Width;
+    UINT Height;
+    UINT Depth;
+    UINT MipLevels;
+    DXGI_FORMAT Format;
+    D3D10_USAGE Usage;
+    UINT BindFlags;
+    UINT CPUAccessFlags;
+    UINT MiscFlags;
+} D3D10_TEXTURE3D_DESC;
+
+typedef enum D3D10_DSV_DIMENSION
+{
+    D3D10_DSV_DIMENSION_UNKNOWN         = 0,
+    D3D10_DSV_DIMENSION_TEXTURE1D       = 1,
+    D3D10_DSV_DIMENSION_TEXTURE1DARRAY  = 2,
+    D3D10_DSV_DIMENSION_TEXTURE2D       = 3,
+    D3D10_DSV_DIMENSION_TEXTURE2DARRAY  = 4,
+    D3D10_DSV_DIMENSION_TEXTURE2DMS     = 5,
+    D3D10_DSV_DIMENSION_TEXTURE2DMSARRAY= 6,
+} D3D10_DSV_DIMENSION;
+
+typedef struct D3D10_TEX1D_DSV {
+    UINT MipSlice;
+} D3D10_TEX1D_DSV;
+
+typedef struct D3D10_TEX1D_ARRAY_DSV {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX1D_ARRAY_DSV;
+
+typedef struct D3D10_TEX2D_DSV {
+    UINT MipSlice;
+} D3D10_TEX2D_DSV;
+
+typedef struct D3D10_TEX2D_ARRAY_DSV {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX2D_ARRAY_DSV;
+
+typedef struct D3D10_TEX2D_DSV {
+    UINT UnusedField_NothingToDefine;
+} D3D10_TEX2DMS_DSV;
+
+typedef struct D3D10_TEX2D_ARRAY_RTV {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX2DMS_ARRAY_DSV;
+
+typedef 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;
+    };
+} D3D10_DEPTH_STENCIL_VIEW_DESC;
+
+typedef enum D3D10_RTV_DIMENSION {
+    D3D10_RTV_DIMENSION_UNKNOWN         = 0,
+    D3D10_RTV_DIMENSION_BUFFER          = 1,
+    D3D10_RTV_DIMENSION_TEXTURE1D       = 2,
+    D3D10_RTV_DIMENSION_TEXTURE1DARRAY  = 3,
+    D3D10_RTV_DIMENSION_TEXTURE2D       = 4,
+    D3D10_RTV_DIMENSION_TEXTURE2DARRAY  = 5,
+    D3D10_RTV_DIMENSION_TEXTURE2DMS     = 6,
+    D3D10_RTV_DIMENSION_TEXTURE2DMSARRAY= 7,
+    D3D10_RTV_DIMENSION_TEXTURE3D       = 8,
+} D3D10_RTV_DIMENSION;
+
+typedef struct D3D10_BUFFER_RTV {
+    UINT ElementOffset;
+    UINT ElementWidth;
+} D3D10_BUFFER_RTV;
+
+typedef struct D3D10_TEX1D_RTV {
+    UINT MipSlice;
+} D3D10_TEX1D_RTV;
+
+typedef struct D3D10_TEX1D_ARRAY_RTV {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX1D_ARRAY_RTV;
+
+typedef struct D3D10_TEX2D_RTV {
+    UINT MipSlice;
+} D3D10_TEX2D_RTV;
+
+typedef struct D3D10_TEX2D_ARRAY_RTV {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX2D_ARRAY_RTV;
+
+typedef struct D3D10_TEX2D_RTV {
+    UINT UnusedField_NothingToDefine;
+} D3D10_TEX2DMS_RTV;
+
+typedef struct D3D10_TEX2D_ARRAY_RTV {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX2DMS_ARRAY_RTV;
+
+typedef struct D3D10_TEX3D_RTV {
+    UINT MipSlice;
+    UINT FirstWSlice;
+    UINT WSize;
+} D3D10_TEX3D_RTV;
+
+typedef 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;
+    };
+} D3D10_RENDER_TARGET_VIEW_DESC;
+
+typedef enum D3D10_SRV_DIMENSION {
+    D3D10_SRV_DIMENSION_UNKNOWN         = 0,
+    D3D10_SRV_DIMENSION_BUFFER          = 1,
+    D3D10_SRV_DIMENSION_TEXTURE1D       = 2,
+    D3D10_SRV_DIMENSION_TEXTURE1DARRAY  = 3,
+    D3D10_SRV_DIMENSION_TEXTURE2D       = 4,
+    D3D10_SRV_DIMENSION_TEXTURE2DARRAY  = 5,
+    D3D10_SRV_DIMENSION_TEXTURE2DMS     = 6,
+    D3D10_SRV_DIMENSION_TEXTURE2DMSARRAY= 7,
+    D3D10_SRV_DIMENSION_TEXTURE3D       = 8,
+    D3D10_SRV_DIMENSION_TEXTURECUBE     = 9,
+} D3D10_SRV_DIMENSION;
+
+typedef struct D3D10_BUFFER_SRV {
+    UINT ElementOffset;
+    UINT ElementWidth;
+} D3D10_BUFFER_SRV;
+
+typedef struct D3D10_TEX1D_SRV {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+} D3D10_TEX1D_SRV;
+
+typedef struct D3D10_TEX1D_ARRAY_SRV {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX1D_ARRAY_SRV;
+
+typedef struct D3D10_TEX2D_SRV {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+} D3D10_TEX2D_SRV;
+
+typedef struct D3D10_TEX2D_ARRAY_SRV {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX2D_ARRAY_SRV;
+
+typedef struct D3D10_TEX2D_SRV {
+    UINT UnusedField_NothingToDefine;
+} D3D10_TEX2DMS_SRV;
+
+typedef struct D3D10_TEX2D_ARRAY_RTV {
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D10_TEX2DMS_ARRAY_SRV;
+
+typedef struct D3D10_TEX3D_SRV {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+} D3D10_TEX3D_SRV;
+
+typedef struct D3D10_TEXCUBE_SRV {
+    UINT MostDetailedMip;
+    UINT MipLevels;
+} D3D10_TEXCUBE_SRV;
+
+typedef 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;
+    };
+} D3D10_SHADER_RESOURCE_VIEW_DESC;
+
+typedef struct D3D10_BOX {
+    UINT left;
+    UINT top;
+    UINT front;
+    UINT right;
+    UINT bottom;
+    UINT back;
+} D3D10_BOX;
+
+typedef struct D3D10_SUBRESOURCE_DATA {
+    const void *pSysMem;
+    UINT SysMemPitch;
+    UINT SysMemSlicePitch;
+} D3D10_SUBRESOURCE_DATA;
+
+typedef struct D3D10_SO_DECLARATION_ENTRY {
+    LPCSTR SemanticName;
+    UINT SemanticIndex;
+    BYTE StartComponent;
+    BYTE ComponentCount;
+    BYTE OutputSlot;
+} D3D10_SO_DECLARATION_ENTRY;
+
+typedef enum D3D10_INPUT_CLASSIFICATION {
+    D3D10_INPUT_PER_VERTEX_DATA = 0,
+    D3D10_INPUT_PER_INSTANCE_DATA = 1,
+} D3D10_INPUT_CLASSIFICATION;
+
+typedef struct D3D10_INPUT_ELEMENT_DESC {
+    LPCSTR SemanticName;
+    UINT SemanticIndex;
+    DXGI_FORMAT Format;
+    UINT InputSlot;
+    UINT AlignedByteOffset;
+    D3D10_INPUT_CLASSIFICATION InputSlotClass;
+    UINT InstanceDataStepRate;
+} D3D10_INPUT_ELEMENT_DESC;
+
+typedef 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 ),
+} D3D10_QUERY;
+
+typedef struct D3D10_QUERY_DESC {
+    D3D10_QUERY Query;
+    UINT MiscFlags;
+} D3D10_QUERY_DESC;
+
+typedef 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,
+} D3D10_PRIMITIVE_TOPOLOGY;
+
+typedef RECT D3D10_RECT;
+
+typedef struct D3D10_VIEWPORT {
+    INT TopLeftX;
+    INT TopLeftY;
+    UINT Width;
+    UINT Height;
+    FLOAT MinDepth;
+    FLOAT MaxDepth;
+} D3D10_VIEWPORT;
+
+/* Core */
+
+interface ID3D10Device;
+
+[
+    object,
+    uuid(9b7e4c00-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10DeviceChild : IUnknown
+{
+    void GetDevice(
+            [out] ID3D10Device **ppDevice);
+    HRESULT GetPrivateData(
+            [in] REFGUID guid,
+            [in, out] UINT *pDataSize,
+            [out] void *pData);
+    HRESULT SetPrivateData(
+            [in] REFGUID guid,
+            [in] UINT DataSize,
+            [in] const void *pData);
+    HRESULT SetPrivateDataInterface(
+            [in] REFGUID guid,
+            [in] const IUnknown *pData);
+}
+
+/* Resource */
+
+[
+    object,
+    uuid(9b7e4c01-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Resource : ID3D10DeviceChild
+{
+        void GetType(
+            [out] D3D10_RESOURCE_DIMENSION *rType);
+        void SetEvictionPriority(
+            [in] UINT EvictionPriority);
+        UINT GetEvictionPriority();
+}
+
+[
+    object,
+    uuid(9b7e4c02-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Buffer : ID3D10Resource
+{
+        HRESULT Map(
+            [in] D3D10_MAP MapType,
+            [in] UINT MapFlags,
+            [out] void **ppData);
+        void Unmap();
+        void GetDesc(
+            [out] D3D10_BUFFER_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c03-342c-4106-a19f-4f2704f689F0)
+]
+interface ID3D10Texture1D : ID3D10Resource
+{
+        HRESULT Map(
+            [in] D3D10_MAP MapType,
+            [in] UINT MapFlags,
+            [out] void **ppData);
+        void Unmap(
+            [in] UINT Subresource);
+        void GetDesc(
+            [out] D3D10_TEXTURE1D_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c04-342c-4106-a19f-4f2704f689F0)
+]
+interface ID3D10Texture2D : ID3D10Resource
+{
+        HRESULT Map(
+            [in] D3D10_MAP MapType,
+            [in] UINT MapFlags,
+            [out] void **ppData);
+        void Unmap(
+            [in] UINT Subresource);
+        void GetDesc(
+            [out] D3D10_TEXTURE2D_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c05-342c-4106-a19f-4f2704f689F0)
+]
+interface ID3D10Texture3D : ID3D10Resource
+{
+        HRESULT Map(
+            [in] D3D10_MAP MapType,
+            [in] UINT MapFlags,
+            [out] void **ppData);
+        void Unmap(
+            [in] UINT Subresource);
+        void GetDesc(
+            [out] D3D10_TEXTURE3D_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(c902b03f-60a7-49ba-9936-2a3ab37a7e33)
+]
+interface ID3D10View : ID3D10DeviceChild
+{
+        void GetResource(
+            [out] ID3D10Resource **ppResource);
+}
+
+[
+    object,
+    uuid(9b7e4c09-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10DepthStencilView : ID3D10View
+{
+        void GetDesc(
+            [out] D3D10_DEPTH_STENCIL_VIEW_DESC *pDesc);
+}
+
+
+[
+    object,
+    uuid(9b7e4c08-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10RenderTargetView : ID3D10View
+{
+        void GetDesc(
+            [out] D3D10_RENDER_TARGET_VIEW_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c07-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10ShaderResourceView  : ID3D10View
+{
+        void GetDesc(
+            [out] D3D10_SHADER_RESOURCE_VIEW_DESC *pDesc);
+}
+
+/* Resource End */
+
+[
+    object,
+    uuid(edad8d19-8a35-4d6d-8566-2ea276cde161)
+]
+interface ID3D10BlendState : ID3D10DeviceChild
+{
+    void GetDesc(
+            [out] D3D10_BLEND_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(2b4b1cc8-a4ad-41f8-8322-ca86fc3ec675)
+]
+interface ID3D10DepthStencilState : ID3D10DeviceChild
+{
+    void GetDesc(
+            [out] D3D10_DEPTH_STENCIL_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(6316be88-54cd-4040-ab44-20461bc81f68)
+]
+interface ID3D10GeometryShader  : ID3D10DeviceChild
+{
+}
+
+[
+    object,
+    uuid(9b7e4c0b-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10InputLayout  : ID3D10DeviceChild
+{
+}
+
+[
+    object,
+    uuid(4968b601-9d00-4cde-8346-8e7f675819b6)
+]
+interface ID3D10PixelShader  : ID3D10DeviceChild
+{
+}
+
+[
+    object,
+    uuid(a2a07292-89af-4345-be2e-c53d9fbb6e9f)
+]
+interface ID3D10RasterizerState  : ID3D10DeviceChild
+{
+    void GetDesc(
+            [out] D3D10_RASTERIZER_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c0c-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10SamplerState  : ID3D10DeviceChild
+{
+    void GetDesc(
+            [out] D3D10_SAMPLER_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c0a-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10VertexShader  : ID3D10DeviceChild
+{
+}
+
+[
+    object,
+    uuid(9b7e4c0d-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Asynchronous  : ID3D10DeviceChild
+{
+    void Begin();
+    void End();
+    HRESULT GetData(
+            [out] void *pData,
+            [in] UINT DataSize,
+            [in] UINT GetDataFlags);
+    UINT GetDataSize();
+}
+
+[
+    object,
+    uuid(9b7e4c11-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Counter  : ID3D10Asynchronous
+{
+    void GetDesc(
+            [out] D3D10_COUNTER_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4C0e-342C-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Query : ID3D10Asynchronous
+{
+    void GetDesc(
+            [out] D3D10_QUERY_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(9b7e4c10-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Predicate : ID3D10Query
+{
+}
+
+[
+    object,
+    uuid(9b7e4c0f-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Device : IUnknown
+{
+        void VSSetConstantBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [in] ID3D10Buffer *const *ppConstantBuffers);
+        void PSSetShaderResources(
+            [in] UINT StartSlot,
+            [in] UINT NumViews,
+            [in] ID3D10ShaderResourceView *const *ppShaderResourceViews);
+        void PSSetShader(
+            [in] ID3D10PixelShader *pPixelShader);
+        void PSSetSamplers(
+            [in] UINT StartSlot,
+            [in] UINT NumSamplers,
+            [in]ID3D10SamplerState *const *ppSamplers);
+        void VSSetShader(
+            [in] ID3D10VertexShader *pVertexShader);
+        void DrawIndexed(
+            [in] UINT IndexCount,
+            [in] UINT StartIndexLocation,
+            [in] INT BaseVertexLocation);
+        void Draw(
+            [in] UINT VertexCount,
+            [in] UINT StartVertexLocation);
+        void PSSetConstantBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [in] ID3D10Buffer *const *ppConstantBuffers);
+        void IASetInputLayout(
+            [in] ID3D10InputLayout *pInputLayout);
+        void IASetVertexBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [in] ID3D10Buffer *const *ppVertexBuffers,
+            [in] const UINT *pStrides,
+            [in] const UINT *pOffsets);
+        void IASetIndexBuffer(
+            [in] ID3D10Buffer *pIndexBuffer,
+            [in] DXGI_FORMAT Format,
+            [in] UINT Offset);
+        void DrawIndexedInstanced(
+            [in] UINT IndexCountPerInstance,
+            [in] UINT InstanceCount,
+            [in] UINT StartIndexLocation,
+            [in] INT BaseVertexLocation,
+            [in] UINT StartInstanceLocation);
+        void DrawInstanced(
+            [in] UINT VertexCountPerInstance,
+            [in] UINT InstanceCount,
+            [in] UINT StartVertexLocation,
+            [in] UINT StartInstanceLocation);
+        void GSSetConstantBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [in] ID3D10Buffer *const *ppConstantBuffers);
+        void GSSetShader(
+            [in] ID3D10GeometryShader *pShader);
+        void IASetPrimitiveTopology(
+            [in] D3D10_PRIMITIVE_TOPOLOGY Topology);
+        void VSSetShaderResources(
+            [in] UINT StartSlot,
+            [in] UINT NumViews,
+            [in] ID3D10ShaderResourceView *const *ppShaderResourceViews);
+        void VSSetSamplers(
+            [in] UINT StartSlot,
+            [in] UINT NumSamplers,
+            [in] ID3D10SamplerState *const *ppSamplers);
+        void SetPredication(
+            [in] ID3D10Predicate *pPredicate,
+            [in] BOOL PredicateValue);
+        void GSSetShaderResources(
+            [in] UINT StartSlot,
+            [in] UINT NumViews,
+            [in] ID3D10ShaderResourceView * const *ppShaderResourceViews);
+        void GSSetSamplers(
+            [in] UINT StartSlot,
+            [in] UINT NumSamplers,
+            [in] ID3D10SamplerState *const *ppSamplers);
+        void OMSetRenderTargets(
+            [in] UINT NumViews,
+            [in] ID3D10RenderTargetView *const *ppRenderTargetViews,
+            [in] ID3D10DepthStencilView *pDepthStencilView);
+        void OMSetBlendState(
+            [in] ID3D10BlendState *pBlendState,
+            [in] const FLOAT BlendFactor[4],
+            [in] UINT SampleMask);
+        void OMSetDepthStencilState(
+            [in] ID3D10DepthStencilState *pDepthStencilState,
+            [in] UINT StencilRef);
+        void SOSetTargets(
+            [in] UINT NumBuffers,
+            [in] ID3D10Buffer *const *ppSOTargets,
+            [in] const UINT *pOffsets);
+        void DrawAuto();
+        void RSSetState(
+            [in] ID3D10RasterizerState *pRasterizerState);
+        void RSSetViewports(
+            [in] UINT NumViewports,
+            [in] const D3D10_VIEWPORT *pViewports);
+        void RSSetScissorRects(
+            [in] UINT NumRects,
+            [in] const D3D10_RECT *pRects);
+        void CopySubresourceRegion(
+            [in] ID3D10Resource *pDstResource,
+            [in] UINT DstSubresource,
+            [in] UINT DstX,
+            [in] UINT DstY,
+            [in] UINT DstZ,
+            [in] ID3D10Resource *pSrcResource,
+            [in] UINT SrcSubresource,
+            [in] const D3D10_BOX *pSrcBox);
+        void CopyResource(
+            [in] ID3D10Resource *pDstResource,
+            [in] ID3D10Resource *pSrcResource);
+        void UpdateSubresource(
+            [in] ID3D10Resource *pDstResource,
+            [in] UINT DstSubresource,
+            [in] const D3D10_BOX *pDstBox,
+            [in] const void *pSrcData,
+            [in] UINT SrcRowPitch,
+            [in] UINT SrcDepthPitch);
+        void ClearRenderTargetView(
+            [in] ID3D10RenderTargetView *pRenderTargetView,
+            [in] const FLOAT ColorRGBA[4]);
+        void ClearDepthStencilView(
+            [in] ID3D10DepthStencilView *pDepthStencilView,
+            [in] UINT ClearFlags,
+            [in] FLOAT Depth,
+            [in] UINT8 Stencil);
+        void GenerateMips(
+            [in] ID3D10ShaderResourceView *pShaderResourceView);
+        void ResolveSubresource(
+            [in] ID3D10Resource *pDstResource,
+            [in] UINT DstSubresource,
+            [in] ID3D10Resource *pSrcResource,
+            [in] UINT SrcSubresource,
+            [in] DXGI_FORMAT Format);
+        void VSGetConstantBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [out] ID3D10Buffer **ppConstantBuffers);
+        void PSGetShaderResources(
+            [in] UINT StartSlot,
+            [in] UINT NumViews,
+            [out] ID3D10ShaderResourceView **ppShaderResourceViews);
+        void PSGetShader(
+            [out] ID3D10PixelShader **ppPixelShader);
+        void PSGetSamplers(
+            [in] UINT StartSlot,
+            [in] UINT NumSamplers,
+            [out] ID3D10SamplerState **ppSamplers);
+        void VSGetShader(
+            [out] ID3D10VertexShader **ppVertexShader);
+        void PSGetConstantBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [out] ID3D10Buffer **ppConstantBuffers);
+        void IAGetInputLayout(
+            [out] ID3D10InputLayout **ppInputLayout);
+        void IAGetVertexBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [out] ID3D10Buffer **ppVertexBuffers,
+            [out] UINT *pStrides,
+            [out] UINT *pOffsets);
+        void IAGetIndexBuffer(
+            [out] ID3D10Buffer **pIndexBuffer,
+            [out] DXGI_FORMAT *Format,
+            [out] UINT *Offset);
+        void GSGetConstantBuffers(
+            [in] UINT StartSlot,
+            [in] UINT NumBuffers,
+            [out] ID3D10Buffer **ppConstantBuffers);
+        void GSGetShader(
+            [out] ID3D10GeometryShader **ppGeometryShader);
+        void IAGetPrimitiveTopology(
+            [out] D3D10_PRIMITIVE_TOPOLOGY *pTopology);
+        void VSGetShaderResources(
+            [in] UINT StartSlot,
+            [in] UINT NumViews,
+            [out] ID3D10ShaderResourceView **ppShaderResourceViews);
+        void VSGetSamplers(
+            [in] UINT StartSlot,
+            [in] UINT NumSamplers,
+            [out] ID3D10SamplerState **ppSamplers);
+        void GetPredication(
+            [out] ID3D10Predicate **ppPredicate,
+            [out]BOOL *pPredicateValue);
+        void GSGetShaderResources(
+            [in] UINT StartSlot,
+            [in] UINT NumViews,
+            [out] ID3D10ShaderResourceView **ppShaderResourceViews);
+        void GSGetSamplers(
+            [in] UINT StartSlot,
+            [in] UINT NumSamplers,
+            [out] ID3D10SamplerState **ppSamplers);
+        void OMGetRenderTargets(
+            [in] UINT NumViews,
+            [out] ID3D10RenderTargetView **ppRenderTargetViews,
+            [out]ID3D10DepthStencilView **ppDepthStencilView);
+        void OMGetBlendState(
+            [out] ID3D10BlendState **ppBlendState,
+            [out] FLOAT BlendFactor[4],
+            [out] UINT *pSampleMask);
+        void OMGetDepthStencilState(
+            [out] ID3D10DepthStencilState **ppDepthStencilState,
+            [out] UINT *pStencilRef);
+        void SOGetTargets(
+            [in] UINT NumBuffers,
+            [out] ID3D10Buffer **ppSOTargets,
+            [out] UINT *pOffsets);
+        void RSGetState(
+            [out] ID3D10RasterizerState **ppRasterizerState);
+        void RSGetViewports(
+            [in, out] UINT *NumViewports,
+            [out] D3D10_VIEWPORT *pViewports);
+        void RSGetScissorRects(
+            [in, out] UINT *NumRects,
+            [out] D3D10_RECT *pRects);
+        HRESULT GetDeviceRemovedReason();
+        HRESULT SetExceptionMode(
+            [in] UINT RaiseFlags);
+        UINT GetExceptionMode();
+        HRESULT GetPrivateData(
+            [in] REFGUID guid,
+            [in, out] UINT *pDataSize,
+            [out] void *pData);
+        HRESULT SetPrivateData(
+            [in] REFGUID guid,
+            [in] UINT DataSize,
+            [in] const void *pData);
+        HRESULT SetPrivateDataInterface(
+            [in] REFGUID guid,
+            [in] const IUnknown *pData);
+        void ClearState();
+        void Flush();
+        HRESULT CreateBuffer(
+            [in] const D3D10_BUFFER_DESC *pDesc,
+            [in] const D3D10_SUBRESOURCE_DATA *pInitialData,
+            [out] ID3D10Buffer **ppBuffer);
+        HRESULT CreateTexture1D(
+            [in] const D3D10_TEXTURE1D_DESC *pDesc,
+            [in] const D3D10_SUBRESOURCE_DATA *pInitialData,
+            [out] ID3D10Texture1D **ppTexture1D);
+        HRESULT CreateTexture2D(
+            [in] const D3D10_TEXTURE2D_DESC *pDesc,
+            [in] const D3D10_SUBRESOURCE_DATA *pInitialData,
+            [out] ID3D10Texture2D **ppTexture1D);
+        HRESULT CreateTexture3D(
+            [in] const D3D10_TEXTURE3D_DESC *pDesc,
+            [in] const D3D10_SUBRESOURCE_DATA *pInitialData,
+            [out] ID3D10Texture3D **ppTexture1D);
+        HRESULT CreateShaderResourceView(
+            [in] ID3D10Resource *pResource,
+            [in] const D3D10_SHADER_RESOURCE_VIEW_DESC *pDesc,
+            [out] ID3D10ShaderResourceView **ppSRView);
+        HRESULT CreateRenderTargetView(
+            [in] ID3D10Resource *pResource,
+            [in] const D3D10_RENDER_TARGET_VIEW_DESC *pDesc,
+            [out] ID3D10RenderTargetView **ppRTView);
+        HRESULT CreateDepthStencilView(
+            [in] ID3D10Resource *pResource,
+            [in] const D3D10_DEPTH_STENCIL_VIEW_DESC *pDesc,
+            [out] ID3D10DepthStencilView **ppDepthStencilView);
+        HRESULT CreateInputLayout(
+            [in] const D3D10_INPUT_ELEMENT_DESC *pInputElementDescs,
+            [in] UINT NumElements,
+            [in] const void *pShaderBytecodeWithInputSignature,
+            [in] SIZE_T BytecodeLength,
+            [out] ID3D10InputLayout **ppInputLayout);
+        HRESULT CreateVertexShader(
+            [in] const void *pShaderBytecode,
+            [in] SIZE_T BytecodeLength,
+            [out] ID3D10VertexShader **ppVertexShader);
+        HRESULT CreateGeometryShader(
+            [in] const void *pShaderBytecode,
+            [in] SIZE_T BytecodeLength,
+            [out] ID3D10GeometryShader **ppGeometryShader);
+        HRESULT CreateGeometryShaderWithStreamOutput(
+            [in] const void *pShaderBytecode,
+            [in] SIZE_T BytecodeLength,
+            [in] const D3D10_SO_DECLARATION_ENTRY *pSODeclaration,
+            [in] UINT NumEntries,
+            [in] UINT OutputStreamStride,
+            [out] ID3D10GeometryShader **ppGeometryShader);
+        HRESULT CreatePixelShader(
+            [in] const void *pShaderBytecode,
+            [in] SIZE_T BytecodeLength,
+            [out] ID3D10PixelShader **ppPixelShader);
+        HRESULT CreateBlendState(
+            [in] const D3D10_BLEND_DESC *pBlendStateDesc,
+            [out] ID3D10BlendState **ppBlendState);
+        HRESULT CreateDepthStencilState(
+            [in] const D3D10_DEPTH_STENCIL_DESC *pDepthStencilDesc,
+            [out] ID3D10DepthStencilState **ppDepthStencilState);
+        HRESULT CreateRasterizerState(
+            [in] const D3D10_RASTERIZER_DESC *pRasterizerDesc,
+            [out] ID3D10RasterizerState **ppRasterizerState);
+        HRESULT CreateSamplerState(
+            [in] const D3D10_SAMPLER_DESC *pSamplerDesc,
+            [out] ID3D10SamplerState **ppSamplerState);
+        HRESULT CreateQuery(
+            [in] const D3D10_QUERY_DESC *pQueryDesc,
+            [out] ID3D10Query **ppQuery);
+        HRESULT CreatePredicate(
+            [in] const D3D10_QUERY_DESC *pPredicateDesc,
+            [out] ID3D10Predicate **ppPredicate);
+        HRESULT CreateCounter(
+            [in] const D3D10_COUNTER_DESC *pCounterDesc,
+            [out] ID3D10Counter **ppCounter);
+        HRESULT CheckFormatSupport(
+            [in] DXGI_FORMAT Format,
+            [out] UINT *pFormatSupport);
+        HRESULT CheckMultisampleQualityLevels(
+            [in] DXGI_FORMAT Format,
+            [in] UINT SampleCount,
+            [out] UINT *pNumQualityLevels);
+        void CheckCounterInfo(
+            [out] D3D10_COUNTER_INFO *pCounterInfo);
+        HRESULT CheckCounter(
+            [in] const D3D10_COUNTER_DESC *pDesc,
+            [out] D3D10_COUNTER_TYPE *pType,
+            [out] UINT *pActiveCounters,
+            [out] LPSTR szName,
+            [in, out] UINT *pNameLength,
+            [out] LPSTR szUnits,
+            [in, out] UINT *pUnitsLength,
+            [out] LPSTR szDescription,
+            [in, out] UINT *pDescriptionLength);
+        UINT GetCreationFlags();
+        HRESULT OpenSharedResource(
+            [in] HANDLE hResource,
+            [in] REFIID ReturnedInterface,
+            [out] void **ppResource);
+        void SetTextFilterSize(
+            [in] UINT Width,
+            [in] UINT Height);
+        void GetTextFilterSize(
+            [out] UINT *Width,
+            [out] UINT *Height);
+}
+
+[
+    object,
+    uuid(9b7e4e00-342c-4106-a19f-4f2704f689f0)
+]
+interface ID3D10Multithread : IUnknown
+{
+        void Enter();
+        void Leave();
+        BOOL SetMultithreadProtected(
+            [in] BOOL bMTProtect);
+        BOOL GetMultithreadProtected();
+}
diff --git a/include/dxgitype.idl b/include/dxgitype.idl
new file mode 100644
index 0000000..af753b3
--- /dev/null
+++ b/include/dxgitype.idl
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2007 Andras Kovacs
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+import "unknwn.idl";
+
+typedef struct DXGI_SAMPLE_DESC {
+    UINT Count;
+    UINT Quality;
+} DXGI_SAMPLE_DESC, *LPDXGI_SAMPLE_DESC;
+
+typedef enum DXGI_FORMAT {
+    DXGI_FORMAT_UNKNOWN	                = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS   = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT      = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT       = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT       = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS      = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT         = 6,
+    DXGI_FORMAT_R32G32B32_UINT          = 7,
+    DXGI_FORMAT_R32G32B32_SINT          = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS   = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT      = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM      = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT       = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM      = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT       = 14,
+    DXGI_FORMAT_R32G32_TYPELESS         = 15,
+    DXGI_FORMAT_R32G32_FLOAT            = 16,
+    DXGI_FORMAT_R32G32_UINT             = 17,
+    DXGI_FORMAT_R32G32_SINT             = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS       = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT    = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS= 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS    = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM       = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT        = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT         = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS       = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM          = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB     = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT           = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM          = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT           = 32,
+    DXGI_FORMAT_R16G16_TYPELESS         = 33,
+    DXGI_FORMAT_R16G16_FLOAT            = 34,
+    DXGI_FORMAT_R16G16_UNORM            = 35,
+    DXGI_FORMAT_R16G16_UINT             = 36,
+    DXGI_FORMAT_R16G16_SNORM            = 37,
+    DXGI_FORMAT_R16G16_SINT             = 38,
+    DXGI_FORMAT_R32_TYPELESS            = 39,
+    DXGI_FORMAT_D32_FLOAT               = 40,
+    DXGI_FORMAT_R32_FLOAT               = 41,
+    DXGI_FORMAT_R32_UINT                = 42,
+    DXGI_FORMAT_R32_SINT                = 43,
+    DXGI_FORMAT_R24G8_TYPELESS          = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT       = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS   = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT    = 47,
+    DXGI_FORMAT_R8G8_TYPELESS           = 48,
+    DXGI_FORMAT_R8G8_UNORM              = 49,
+    DXGI_FORMAT_R8G8_UINT               = 50,
+    DXGI_FORMAT_R8G8_SNORM              = 51,
+    DXGI_FORMAT_R8G8_SINT               = 52,
+    DXGI_FORMAT_R16_TYPELESS            = 53,
+    DXGI_FORMAT_R16_FLOAT               = 54,
+    DXGI_FORMAT_D16_UNORM               = 55,
+    DXGI_FORMAT_R16_UNORM               = 56,
+    DXGI_FORMAT_R16_UINT                = 57,
+    DXGI_FORMAT_R16_SNORM               = 58,
+    DXGI_FORMAT_R16_SINT                = 59,
+    DXGI_FORMAT_R8_TYPELESS             = 60,
+    DXGI_FORMAT_R8_UNORM                = 61,
+    DXGI_FORMAT_R8_UINT                 = 62,
+    DXGI_FORMAT_R8_SNORM                = 63,
+    DXGI_FORMAT_R8_SINT                 = 64,
+    DXGI_FORMAT_A8_UNORM                = 65,
+    DXGI_FORMAT_R1_UNORM                = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP	= 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM         = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM         = 69,
+    DXGI_FORMAT_BC1_TYPELESS            = 70,
+    DXGI_FORMAT_BC1_UNORM               = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB          = 72,
+    DXGI_FORMAT_BC2_TYPELESS            = 73,
+    DXGI_FORMAT_BC2_UNORM               = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB          = 75,
+    DXGI_FORMAT_BC3_TYPELESS            = 76,
+    DXGI_FORMAT_BC3_UNORM               = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB          = 78,
+    DXGI_FORMAT_BC4_TYPELESS            = 79,
+    DXGI_FORMAT_BC4_UNORM               = 80,
+    DXGI_FORMAT_BC4_SNORM               = 81,
+    DXGI_FORMAT_BC5_TYPELESS            = 82,
+    DXGI_FORMAT_BC5_UNORM               = 83,
+    DXGI_FORMAT_BC5_SNORM               = 84,
+    DXGI_FORMAT_B5G6R5_UNORM            = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM          = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM          = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM          = 88,
+    DXGI_FORMAT_FORCE_UINT              = 0xffffffff
+} DXGI_FORMAT;
-- 
1.4.4.4



More information about the wine-patches mailing list