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