diff options
Diffstat (limited to 'src/VBox/Devices/Graphics/shaderlib/wine/include/d3d11.idl')
| -rw-r--r-- | src/VBox/Devices/Graphics/shaderlib/wine/include/d3d11.idl | 2010 |
1 files changed, 2010 insertions, 0 deletions
diff --git a/src/VBox/Devices/Graphics/shaderlib/wine/include/d3d11.idl b/src/VBox/Devices/Graphics/shaderlib/wine/include/d3d11.idl new file mode 100644 index 00000000..41c92489 --- /dev/null +++ b/src/VBox/Devices/Graphics/shaderlib/wine/include/d3d11.idl @@ -0,0 +1,2010 @@ +/* + * Copyright 2010 Rico Schüller + * Copyright 2013 Austin English + * + * 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 + */ + +/* + * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice + * other than GPL or LGPL is available it will apply instead, Oracle elects to use only + * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where + * a choice of LGPL license versions is made available with the language indicating + * that LGPLv2 or any later version may be used, or where a choice of which version + * of the LGPL is applied is otherwise unspecified. + */ + +import "oaidl.idl"; +import "ocidl.idl"; +import "dxgi.idl"; +import "d3dcommon.idl"; + +typedef D3D_PRIMITIVE D3D11_PRIMITIVE; +typedef D3D_PRIMITIVE_TOPOLOGY D3D11_PRIMITIVE_TOPOLOGY; +typedef D3D_SRV_DIMENSION D3D11_SRV_DIMENSION; +typedef RECT D3D11_RECT; + +const UINT D3D11_DEFAULT_DEPTH_BIAS = 0; +cpp_quote("#define D3D11_DEFAULT_DEPTH_BIAS_CLAMP 0.0f") +const UINT D3D11_DEFAULT_MAX_ANISOTROPY = 16; +cpp_quote("#define D3D11_DEFAULT_MIP_LOD_BIAS 0.0f") +const UINT D3D11_DEFAULT_RENDER_TARGET_ARRAY_INDEX = 0; +const UINT D3D11_DEFAULT_SAMPLE_MASK = 0xffffffff; +const UINT D3D11_DEFAULT_SCISSOR_ENDX = 0; +const UINT D3D11_DEFAULT_SCISSOR_ENDY = 0; +const UINT D3D11_DEFAULT_SCISSOR_STARTX = 0; +const UINT D3D11_DEFAULT_SCISSOR_STARTY = 0; +cpp_quote("#define D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS 0.0f") +const UINT D3D11_DEFAULT_STENCIL_READ_MASK = 0xff; +const UINT D3D11_DEFAULT_STENCIL_REFERENCE = 0; +const UINT D3D11_DEFAULT_STENCIL_WRITE_MASK = 0xff; +const UINT D3D11_DEFAULT_VIEWPORT_AND_SCISSORRECT_INDEX = 0; +const UINT D3D11_DEFAULT_VIEWPORT_HEIGHT = 0; +cpp_quote("#define D3D11_DEFAULT_VIEWPORT_MAX_DEPTH 0.0f") +cpp_quote("#define D3D11_DEFAULT_VIEWPORT_MIN_DEPTH 0.0f") +const UINT D3D11_DEFAULT_VIEWPORT_TOPLEFTX = 0; +const UINT D3D11_DEFAULT_VIEWPORT_TOPLEFTY = 0; +const UINT D3D11_DEFAULT_VIEWPORT_WIDTH = 0; + +cpp_quote("#define D3D11_FLOAT32_MAX (3.402823466e+38f)") + +const unsigned int D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT = 8; + +const UINT D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION = 16384; +const UINT D3D11_MAX_MAXANISOTROPY = 16; +const UINT D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT = 32; +const UINT D3D11_VIEWPORT_BOUNDS_MAX = 32767; +const INT D3D11_VIEWPORT_BOUNDS_MIN = -32768; +const UINT D3D11_SHADER_MAJOR_VERSION = 5; +const UINT D3D11_SHADER_MAX_INSTANCES = 65535; +const UINT D3D11_SHADER_MAX_INTERFACES = 253; +const UINT D3D11_SHADER_MAX_INTERFACE_CALL_SITES = 4096; +const UINT D3D11_SHADER_MAX_TYPES = 65535; +const UINT D3D11_SHADER_MINOR_VERSION = 0; +const UINT D3D11_VS_OUTPUT_REGISTER_COUNT = 32; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_DEFAULT {};") +cpp_quote("extern const DECLSPEC_SELECTANY CD3D11_DEFAULT D3D11_DEFAULT;") +cpp_quote("#endif") + +typedef enum D3D11_BLEND +{ + D3D11_BLEND_ZERO = 1, + D3D11_BLEND_ONE = 2, + D3D11_BLEND_SRC_COLOR = 3, + D3D11_BLEND_INV_SRC_COLOR = 4, + D3D11_BLEND_SRC_ALPHA = 5, + D3D11_BLEND_INV_SRC_ALPHA = 6, + D3D11_BLEND_DEST_ALPHA = 7, + D3D11_BLEND_INV_DEST_ALPHA = 8, + D3D11_BLEND_DEST_COLOR = 9, + D3D11_BLEND_INV_DEST_COLOR = 10, + D3D11_BLEND_SRC_ALPHA_SAT = 11, + D3D11_BLEND_BLEND_FACTOR = 14, + D3D11_BLEND_INV_BLEND_FACTOR = 15, + D3D11_BLEND_SRC1_COLOR = 16, + D3D11_BLEND_INV_SRC1_COLOR = 17, + D3D11_BLEND_SRC1_ALPHA = 18, + D3D11_BLEND_INV_SRC1_ALPHA = 19, +} D3D11_BLEND; + +typedef enum D3D11_BLEND_OP +{ + D3D11_BLEND_OP_ADD = 1, + D3D11_BLEND_OP_SUBTRACT, + D3D11_BLEND_OP_REV_SUBTRACT, + D3D11_BLEND_OP_MIN, + D3D11_BLEND_OP_MAX +} D3D11_BLEND_OP; + +typedef struct D3D11_BOX +{ + UINT left; + UINT top; + UINT front; + UINT right; + UINT bottom; + UINT back; +} D3D11_BOX; + +typedef struct D3D11_BUFFER_RTV +{ + union + { + UINT FirstElement; + UINT ElementOffset; + }; + union + { + UINT NumElements; + UINT ElementWidth; + }; +} D3D11_BUFFER_RTV; + +typedef struct D3D11_BUFFER_SRV +{ + union + { + UINT FirstElement; + UINT ElementOffset; + }; + union + { + UINT NumElements; + UINT ElementWidth; + }; +} D3D11_BUFFER_SRV; + +typedef struct D3D11_BUFFER_UAV +{ + UINT FirstElement; + UINT NumElements; + UINT Flags; +} D3D11_BUFFER_UAV; + +typedef struct D3D11_BUFFEREX_SRV +{ + UINT FirstElement; + UINT NumElements; + UINT Flags; +} D3D11_BUFFEREX_SRV; + +typedef struct D3D11_CLASS_INSTANCE_DESC +{ + UINT InstanceId; + UINT InstanceIndex; + UINT TypeId; + UINT ConstantBuffer; + UINT BaseConstantBufferOffset; + UINT BaseTexture; + UINT BaseSampler; + BOOL Created; +} D3D11_CLASS_INSTANCE_DESC; + +typedef enum D3D11_COMPARISON_FUNC +{ + D3D11_COMPARISON_NEVER = 1, + D3D11_COMPARISON_LESS, + D3D11_COMPARISON_EQUAL, + D3D11_COMPARISON_LESS_EQUAL, + D3D11_COMPARISON_GREATER, + D3D11_COMPARISON_NOT_EQUAL, + D3D11_COMPARISON_GREATER_EQUAL, + D3D11_COMPARISON_ALWAYS +} D3D11_COMPARISON_FUNC; + +typedef enum D3D11_COUNTER +{ + D3D11_COUNTER_DEVICE_DEPENDENT_0 = 0x40000000, +} D3D11_COUNTER; + +typedef struct D3D11_COUNTER_DESC +{ + D3D11_COUNTER Counter; + UINT MiscFlags; +} D3D11_COUNTER_DESC; + +typedef struct D3D11_COUNTER_INFO +{ + D3D11_COUNTER LastDeviceDependentCounter; + UINT NumSimultaneousCounters; + UINT8 NumDetectableParallelUnits; +} D3D11_COUNTER_INFO; + +typedef enum D3D11_COUNTER_TYPE +{ + D3D11_COUNTER_TYPE_FLOAT32, + D3D11_COUNTER_TYPE_UINT16, + D3D11_COUNTER_TYPE_UINT32, + D3D11_COUNTER_TYPE_UINT64, +} D3D11_COUNTER_TYPE; + +typedef enum D3D11_CULL_MODE +{ + D3D11_CULL_NONE = 1, + D3D11_CULL_FRONT, + D3D11_CULL_BACK +} D3D11_CULL_MODE; + +typedef enum D3D11_DEPTH_WRITE_MASK +{ + D3D11_DEPTH_WRITE_MASK_ZERO, + D3D11_DEPTH_WRITE_MASK_ALL, +} D3D11_DEPTH_WRITE_MASK; + +typedef enum D3D11_DEVICE_CONTEXT_TYPE +{ + D3D11_DEVICE_CONTEXT_IMMEDIATE, + D3D11_DEVICE_CONTEXT_DEFERRED, +} D3D11_DEVICE_CONTEXT_TYPE; + +typedef enum D3D11_DSV_DIMENSION +{ + D3D11_DSV_DIMENSION_UNKNOWN, + D3D11_DSV_DIMENSION_TEXTURE1D, + D3D11_DSV_DIMENSION_TEXTURE1DARRAY, + D3D11_DSV_DIMENSION_TEXTURE2D, + D3D11_DSV_DIMENSION_TEXTURE2DARRAY, + D3D11_DSV_DIMENSION_TEXTURE2DMS, + D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY, +} D3D11_DSV_DIMENSION; + +typedef enum D3D11_FEATURE +{ + D3D11_FEATURE_THREADING, + D3D11_FEATURE_DOUBLES, + D3D11_FEATURE_FORMAT_SUPPORT, + D3D11_FEATURE_FORMAT_SUPPORT2, + D3D11_FEATURE_D3D10_X_HARDWARE_OPTIONS, +} D3D11_FEATURE; + +typedef enum D3D11_FILL_MODE +{ + D3D11_FILL_WIREFRAME = 2, + D3D11_FILL_SOLID +} D3D11_FILL_MODE; + +typedef enum D3D11_FILTER_TYPE +{ + D3D11_FILTER_TYPE_POINT = 0, + D3D11_FILTER_TYPE_LINEAR = 1 +} D3D11_FILTER_TYPE; + +const UINT D3D11_MIN_FILTER_SHIFT = 4; +const UINT D3D11_MAG_FILTER_SHIFT = 2; +const UINT D3D11_MIP_FILTER_SHIFT = 0; +const UINT D3D11_FILTER_TYPE_MASK = 0x00000003; +const UINT D3D11_COMPARISON_FILTERING_BIT = 0x00000080; +const UINT D3D11_ANISOTROPIC_FILTERING_BIT = 0x00000040; + +cpp_quote("#define D3D11_ENCODE_BASIC_FILTER(min, mag, mip, bComparison) \\") +cpp_quote(" ((D3D11_FILTER)(((bComparison) ? D3D11_COMPARISON_FILTERING_BIT : 0 ) | \\") +cpp_quote(" (((min)&D3D11_FILTER_TYPE_MASK) << D3D11_MIN_FILTER_SHIFT) | \\") +cpp_quote(" (((mag)&D3D11_FILTER_TYPE_MASK) << D3D11_MAG_FILTER_SHIFT) | \\") +cpp_quote(" (((mip)&D3D11_FILTER_TYPE_MASK) << D3D11_MIP_FILTER_SHIFT)))") + +cpp_quote("#define D3D11_ENCODE_ANISOTROPIC_FILTER(bComparison) \\") +cpp_quote(" ((D3D11_FILTER)(D3D11_ANISOTROPIC_FILTERING_BIT | \\" ) +cpp_quote(" D3D11_ENCODE_BASIC_FILTER(D3D11_FILTER_TYPE_LINEAR,D3D11_FILTER_TYPE_LINEAR, \\" ) +cpp_quote(" D3D11_FILTER_TYPE_LINEAR,bComparison)))" ) + +cpp_quote("#define D3D11_DECODE_MIN_FILTER(d3d11Filter) \\") +cpp_quote(" ((D3D11_FILTER_TYPE)(((d3d11Filter) >> D3D11_MIN_FILTER_SHIFT) & D3D11_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D11_DECODE_MAG_FILTER(d3d11Filter) \\") +cpp_quote(" ((D3D11_FILTER_TYPE)(((d3d11Filter) >> D3D11_MAG_FILTER_SHIFT) & D3D11_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D11_DECODE_MIP_FILTER(d3d11Filter) \\") +cpp_quote(" ((D3D11_FILTER_TYPE)(((d3d11Filter) >> D3D11_MIP_FILTER_SHIFT) & D3D11_FILTER_TYPE_MASK))") + +cpp_quote("#define D3D11_DECODE_IS_COMPARISON_FILTER(d3d11Filter) ((d3d11Filter) & D3D11_COMPARISON_FILTERING_BIT)") + +cpp_quote("#define D3D11_DECODE_IS_ANISOTROPIC_FILTER(d3d11Filter) \\") +cpp_quote(" (((d3d11Filter) & D3D11_ANISOTROPIC_FILTERING_BIT ) \\" ) +cpp_quote(" && (D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MIN_FILTER(d3d11Filter)) \\" ) +cpp_quote(" && (D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MAG_FILTER(d3d11Filter)) \\" ) +cpp_quote(" && (D3D11_FILTER_TYPE_LINEAR == D3D11_DECODE_MIP_FILTER(d3d11Filter)))") + +typedef enum D3D11_FILTER +{ + D3D11_FILTER_MIN_MAG_MIP_POINT = 0x00, + D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x01, + D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x04, + D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x05, + D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10, + D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11, + D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14, + D3D11_FILTER_MIN_MAG_MIP_LINEAR = 0x15, + D3D11_FILTER_ANISOTROPIC = 0x55, + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80, + D3D11_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81, + D3D11_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84, + D3D11_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85, + D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90, + D3D11_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91, + D3D11_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94, + D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95, + D3D11_FILTER_COMPARISON_ANISOTROPIC = 0xd5 +} D3D11_FILTER; + +typedef enum D3D11_DSV_FLAG +{ + D3D11_DSV_READ_ONLY_DEPTH = 0x1, + D3D11_DSV_READ_ONLY_STENCIL = 0x2, +} D3D11_DSV_FLAG; + +typedef enum D3D11_INPUT_CLASSIFICATION +{ + D3D11_INPUT_PER_VERTEX_DATA, + D3D11_INPUT_PER_INSTANCE_DATA, +} D3D11_INPUT_CLASSIFICATION; + +typedef struct D3D11_INPUT_ELEMENT_DESC +{ + LPCSTR SemanticName; + UINT SemanticIndex; + DXGI_FORMAT Format; + UINT InputSlot; + UINT AlignedByteOffset; + D3D11_INPUT_CLASSIFICATION InputSlotClass; + UINT InstanceDataStepRate; +} D3D11_INPUT_ELEMENT_DESC; + +typedef enum D3D11_MAP +{ + D3D11_MAP_READ = 1, + D3D11_MAP_WRITE, + D3D11_MAP_READ_WRITE, + D3D11_MAP_WRITE_DISCARD, + D3D11_MAP_WRITE_NO_OVERWRITE +} D3D11_MAP; + +typedef struct D3D11_MAPPED_SUBRESOURCE +{ + void *pData; + UINT RowPitch; + UINT DepthPitch; +} D3D11_MAPPED_SUBRESOURCE; + +typedef enum D3D11_QUERY +{ + D3D11_QUERY_EVENT, + D3D11_QUERY_OCCLUSION, + D3D11_QUERY_TIMESTAMP, + D3D11_QUERY_TIMESTAMP_DISJOINT, + D3D11_QUERY_PIPELINE_STATISTICS, + D3D11_QUERY_OCCLUSION_PREDICATE, + D3D11_QUERY_SO_STATISTICS, + D3D11_QUERY_SO_OVERFLOW_PREDICATE, + D3D11_QUERY_SO_STATISTICS_STREAM0, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM0, + D3D11_QUERY_SO_STATISTICS_STREAM1, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM1, + D3D11_QUERY_SO_STATISTICS_STREAM2, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM2, + D3D11_QUERY_SO_STATISTICS_STREAM3, + D3D11_QUERY_SO_OVERFLOW_PREDICATE_STREAM3, +} D3D11_QUERY; + +typedef enum D3D11_ASYNC_GETDATA_FLAG +{ + D3D11_ASYNC_GETDATA_DONOTFLUSH = 0x0001, +} D3D11_ASYNC_GETDATA_FLAG; + +typedef enum D3D11_RESOURCE_MISC_FLAG +{ + D3D11_RESOURCE_MISC_GENERATE_MIPS = 0x00000001L, + D3D11_RESOURCE_MISC_SHARED = 0x00000002L, + D3D11_RESOURCE_MISC_TEXTURECUBE = 0x00000004L, + D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS = 0x00000010L, + D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS = 0x00000020L, + D3D11_RESOURCE_MISC_BUFFER_STRUCTURED = 0x00000040L, + D3D11_RESOURCE_MISC_RESOURCE_CLAMP = 0x00000080L, + D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX = 0x00000100L, + D3D11_RESOURCE_MISC_GDI_COMPATIBLE = 0x00000200L, + D3D11_RESOURCE_MISC_SHARED_NTHANDLE = 0x00000800L, + D3D11_RESOURCE_MISC_RESTRICTED_CONTENT = 0x00001000L, + D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE = 0x00002000L, + D3D11_RESOURCE_MISC_RESTRICT_SHARED_RESOURCE_DRIVER = 0x00004000L, + D3D11_RESOURCE_MISC_GUARDED = 0x00008000L +} D3D11_RESOURCE_MISC_FLAG; + +typedef struct D3D11_QUERY_DESC +{ + D3D11_QUERY Query; + UINT MiscFlags; +} D3D11_QUERY_DESC; + +typedef struct D3D11_RASTERIZER_DESC +{ + D3D11_FILL_MODE FillMode; + D3D11_CULL_MODE CullMode; + BOOL FrontCounterClockwise; + INT DepthBias; + FLOAT DepthBiasClamp; + FLOAT SlopeScaledDepthBias; + BOOL DepthClipEnable; + BOOL ScissorEnable; + BOOL MultisampleEnable; + BOOL AntialiasedLineEnable; +} D3D11_RASTERIZER_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_RASTERIZER_DESC : public D3D11_RASTERIZER_DESC {") +cpp_quote(" CD3D11_RASTERIZER_DESC() {}") +cpp_quote(" explicit CD3D11_RASTERIZER_DESC(const D3D11_RASTERIZER_DESC &o) : D3D11_RASTERIZER_DESC(o) {}") +cpp_quote(" explicit CD3D11_RASTERIZER_DESC(CD3D11_DEFAULT) {") +cpp_quote(" FillMode = D3D11_FILL_SOLID;") +cpp_quote(" CullMode = D3D11_CULL_BACK;") +cpp_quote(" FrontCounterClockwise = FALSE;") +cpp_quote(" DepthBias = D3D11_DEFAULT_DEPTH_BIAS;") +cpp_quote(" DepthBiasClamp = D3D11_DEFAULT_DEPTH_BIAS_CLAMP;") +cpp_quote(" SlopeScaledDepthBias = D3D11_DEFAULT_SLOPE_SCALED_DEPTH_BIAS;") +cpp_quote(" DepthClipEnable = TRUE;") +cpp_quote(" ScissorEnable = FALSE;") +cpp_quote(" MultisampleEnable = FALSE;") +cpp_quote(" AntialiasedLineEnable = FALSE;") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_RASTERIZER_DESC(D3D11_FILL_MODE fillMode, D3D11_CULL_MODE cullMode," ) +cpp_quote(" BOOL frontCounterClockwise, INT depthBias, FLOAT depthBiasClamp, FLOAT slopeScaledDepthBias,") +cpp_quote(" BOOL depthClipEnable, BOOL scissorEnable, BOOL multisampleEnable, BOOL antialiasedLineEnable) {") +cpp_quote(" FillMode = fillMode;") +cpp_quote(" CullMode = cullMode;") +cpp_quote(" FrontCounterClockwise = frontCounterClockwise;") +cpp_quote(" DepthBias = depthBias;") +cpp_quote(" DepthBiasClamp = depthBiasClamp;") +cpp_quote(" SlopeScaledDepthBias = slopeScaledDepthBias;") +cpp_quote(" DepthClipEnable = depthClipEnable;") +cpp_quote(" ScissorEnable = scissorEnable;") +cpp_quote(" MultisampleEnable = multisampleEnable;") +cpp_quote(" AntialiasedLineEnable = antialiasedLineEnable;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_RASTERIZER_DESC() {}") +cpp_quote(" operator const D3D11_RASTERIZER_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef enum D3D11_RESOURCE_DIMENSION +{ + D3D11_RESOURCE_DIMENSION_UNKNOWN, + D3D11_RESOURCE_DIMENSION_BUFFER, + D3D11_RESOURCE_DIMENSION_TEXTURE1D, + D3D11_RESOURCE_DIMENSION_TEXTURE2D, + D3D11_RESOURCE_DIMENSION_TEXTURE3D, +} D3D11_RESOURCE_DIMENSION; + +typedef enum D3D11_RTV_DIMENSION +{ + D3D11_RTV_DIMENSION_UNKNOWN, + D3D11_RTV_DIMENSION_BUFFER, + D3D11_RTV_DIMENSION_TEXTURE1D, + D3D11_RTV_DIMENSION_TEXTURE1DARRAY, + D3D11_RTV_DIMENSION_TEXTURE2D, + D3D11_RTV_DIMENSION_TEXTURE2DARRAY, + D3D11_RTV_DIMENSION_TEXTURE2DMS, + D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY, + D3D11_RTV_DIMENSION_TEXTURE3D, +} D3D11_RTV_DIMENSION; + +typedef struct D3D11_SO_DECLARATION_ENTRY +{ + UINT Stream; + LPCSTR SemanticName; + UINT SemanticIndex; + BYTE StartComponent; + BYTE ComponentCount; + BYTE OutputSlot; +} D3D11_SO_DECLARATION_ENTRY; + +typedef enum D3D11_STENCIL_OP +{ + D3D11_STENCIL_OP_KEEP = 1, + D3D11_STENCIL_OP_ZERO, + D3D11_STENCIL_OP_REPLACE, + D3D11_STENCIL_OP_INCR_SAT, + D3D11_STENCIL_OP_DECR_SAT, + D3D11_STENCIL_OP_INVERT, + D3D11_STENCIL_OP_INCR, + D3D11_STENCIL_OP_DECR +} D3D11_STENCIL_OP; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("}") +cpp_quote("inline UINT D3D11CalcSubresource(UINT MipSlice, UINT ArraySlice, UINT MipLevels) {") +cpp_quote(" return MipSlice + ArraySlice * MipLevels;") +cpp_quote("}") +cpp_quote("extern \"C\"{") +cpp_quote("#endif") + +typedef struct D3D11_SUBRESOURCE_DATA +{ + const void *pSysMem; + UINT SysMemPitch; + UINT SysMemSlicePitch; +} D3D11_SUBRESOURCE_DATA; + +typedef struct D3D11_TEX1D_ARRAY_DSV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_DSV; + +typedef struct D3D11_TEX1D_ARRAY_RTV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_RTV; + +typedef struct D3D11_TEX1D_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_SRV; + +typedef struct D3D11_TEX1D_ARRAY_UAV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX1D_ARRAY_UAV; + +typedef struct D3D11_TEX1D_DSV +{ + UINT MipSlice; +} D3D11_TEX1D_DSV; + +typedef struct D3D11_TEX1D_RTV +{ + UINT MipSlice; +} D3D11_TEX1D_RTV; + +typedef struct D3D11_TEX1D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + } D3D11_TEX1D_SRV; + +typedef struct D3D11_TEX1D_UAV +{ + UINT MipSlice; +} D3D11_TEX1D_UAV; + +typedef struct D3D11_TEX2D_ARRAY_DSV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_DSV; + +typedef struct D3D11_TEX2D_ARRAY_RTV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_RTV; + +typedef struct D3D11_TEX2D_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_SRV; + +typedef struct D3D11_TEX2D_ARRAY_UAV +{ + UINT MipSlice; + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2D_ARRAY_UAV; + +typedef struct D3D11_TEX2D_DSV +{ + UINT MipSlice; +} D3D11_TEX2D_DSV; + +typedef struct D3D11_TEX2D_RTV +{ + UINT MipSlice; +} D3D11_TEX2D_RTV; + +typedef struct D3D11_TEX2D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; +} D3D11_TEX2D_SRV; + +typedef struct D3D11_TEX2D_UAV +{ + UINT MipSlice; +} D3D11_TEX2D_UAV; + +typedef struct D3D11_TEX2DMS_ARRAY_DSV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2DMS_ARRAY_DSV; + +typedef struct D3D11_TEX2DMS_ARRAY_RTV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2DMS_ARRAY_RTV; + +typedef struct D3D11_TEX2DMS_ARRAY_SRV +{ + UINT FirstArraySlice; + UINT ArraySize; +} D3D11_TEX2DMS_ARRAY_SRV; + +typedef struct D3D11_TEX2DMS_DSV +{ + UINT UnusedField_NothingToDefine; +} D3D11_TEX2DMS_DSV; + +typedef struct D3D11_TEX2DMS_RTV +{ + UINT UnusedField_NothingToDefine; +} D3D11_TEX2DMS_RTV; + +typedef struct D3D11_TEX2DMS_SRV +{ + UINT UnusedField_NothingToDefine; +} D3D11_TEX2DMS_SRV; + +typedef struct D3D11_TEX3D_RTV +{ + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D11_TEX3D_RTV; + +typedef struct D3D11_TEX3D_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; +} D3D11_TEX3D_SRV; + +typedef struct D3D11_TEX3D_UAV +{ + UINT MipSlice; + UINT FirstWSlice; + UINT WSize; +} D3D11_TEX3D_UAV; + +typedef struct D3D11_TEXCUBE_ARRAY_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; + UINT First2DArrayFace; + UINT NumCubes; +} D3D11_TEXCUBE_ARRAY_SRV; + +typedef struct D3D11_TEXCUBE_SRV +{ + UINT MostDetailedMip; + UINT MipLevels; +} D3D11_TEXCUBE_SRV; + +typedef enum D3D11_TEXTURE_ADDRESS_MODE +{ + D3D11_TEXTURE_ADDRESS_WRAP = 1, + D3D11_TEXTURE_ADDRESS_MIRROR, + D3D11_TEXTURE_ADDRESS_CLAMP, + D3D11_TEXTURE_ADDRESS_BORDER, + D3D11_TEXTURE_ADDRESS_MIRROR_ONCE +} D3D11_TEXTURE_ADDRESS_MODE; + +typedef enum D3D11_UAV_DIMENSION +{ + D3D11_UAV_DIMENSION_UNKNOWN, + D3D11_UAV_DIMENSION_BUFFER, + D3D11_UAV_DIMENSION_TEXTURE1D, + D3D11_UAV_DIMENSION_TEXTURE1DARRAY, + D3D11_UAV_DIMENSION_TEXTURE2D, + D3D11_UAV_DIMENSION_TEXTURE2DARRAY, + D3D11_UAV_DIMENSION_TEXTURE3D = 8, +} D3D11_UAV_DIMENSION; + +typedef struct D3D11_UNORDERED_ACCESS_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_UAV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_UAV Buffer; + D3D11_TEX1D_UAV Texture1D; + D3D11_TEX1D_ARRAY_UAV Texture1DArray; + D3D11_TEX2D_UAV Texture2D; + D3D11_TEX2D_ARRAY_UAV Texture2DArray; + D3D11_TEX3D_UAV Texture3D; + }; +} D3D11_UNORDERED_ACCESS_VIEW_DESC; + +typedef enum D3D11_USAGE +{ + D3D11_USAGE_DEFAULT, + D3D11_USAGE_IMMUTABLE, + D3D11_USAGE_DYNAMIC, + D3D11_USAGE_STAGING, +} D3D11_USAGE; + +typedef enum D3D11_BIND_FLAG +{ + D3D11_BIND_VERTEX_BUFFER = 0x0001, + D3D11_BIND_INDEX_BUFFER = 0x0002, + D3D11_BIND_CONSTANT_BUFFER = 0x0004, + D3D11_BIND_SHADER_RESOURCE = 0x0008, + D3D11_BIND_STREAM_OUTPUT = 0x0010, + D3D11_BIND_RENDER_TARGET = 0x0020, + D3D11_BIND_DEPTH_STENCIL = 0x0040, + D3D11_BIND_UNORDERED_ACCESS = 0x0080, + D3D11_BIND_DECODER = 0x0200, + D3D11_BIND_VIDEO_ENCODER = 0x0400 +} D3D11_BIND_FLAG; + +typedef enum D3D11_CPU_ACCESS_FLAG +{ + D3D11_CPU_ACCESS_WRITE = 0x00010000, + D3D11_CPU_ACCESS_READ = 0x00020000 +} D3D11_CPU_ACCESS_FLAG; + +typedef struct D3D11_VIEWPORT +{ + FLOAT TopLeftX; + FLOAT TopLeftY; + FLOAT Width; + FLOAT Height; + FLOAT MinDepth; + FLOAT MaxDepth; +} D3D11_VIEWPORT; + +typedef enum D3D11_COLOR_WRITE_ENABLE +{ + D3D11_COLOR_WRITE_ENABLE_RED = 1, + D3D11_COLOR_WRITE_ENABLE_GREEN = 2, + D3D11_COLOR_WRITE_ENABLE_BLUE = 4, + D3D11_COLOR_WRITE_ENABLE_ALPHA = 8, + D3D11_COLOR_WRITE_ENABLE_ALL = + (D3D11_COLOR_WRITE_ENABLE_RED|D3D11_COLOR_WRITE_ENABLE_GREEN|D3D11_COLOR_WRITE_ENABLE_BLUE|D3D11_COLOR_WRITE_ENABLE_ALPHA) +} D3D11_COLOR_WRITE_ENABLE; + +typedef enum D3D11_FORMAT_SUPPORT +{ + D3D11_FORMAT_SUPPORT_BUFFER = 0x00000001, + D3D11_FORMAT_SUPPORT_IA_VERTEX_BUFFER = 0x00000002, + D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER = 0x00000004, + D3D11_FORMAT_SUPPORT_SO_BUFFER = 0x00000008, + D3D11_FORMAT_SUPPORT_TEXTURE1D = 0x00000010, + D3D11_FORMAT_SUPPORT_TEXTURE2D = 0x00000020, + D3D11_FORMAT_SUPPORT_TEXTURE3D = 0x00000040, + D3D11_FORMAT_SUPPORT_TEXTURECUBE = 0x00000080, + D3D11_FORMAT_SUPPORT_SHADER_LOAD = 0x00000100, + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE = 0x00000200, + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON = 0x00000400, + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_MONO_TEXT = 0x00000800, + D3D11_FORMAT_SUPPORT_MIP = 0x00001000, + D3D11_FORMAT_SUPPORT_MIP_AUTOGEN = 0x00002000, + D3D11_FORMAT_SUPPORT_RENDER_TARGET = 0x00004000, + D3D11_FORMAT_SUPPORT_BLENDABLE = 0x00008000, + D3D11_FORMAT_SUPPORT_DEPTH_STENCIL = 0x00010000, + D3D11_FORMAT_SUPPORT_CPU_LOCKABLE = 0x00020000, + D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE = 0x00040000, + D3D11_FORMAT_SUPPORT_DISPLAY = 0x00080000, + D3D11_FORMAT_SUPPORT_CAST_WITHIN_BIT_LAYOUT = 0x00100000, + D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET = 0x00200000, + D3D11_FORMAT_SUPPORT_MULTISAMPLE_LOAD = 0x00400000, + D3D11_FORMAT_SUPPORT_SHADER_GATHER = 0x00800000, + D3D11_FORMAT_SUPPORT_BACK_BUFFER_CAST = 0x01000000, + D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW = 0x02000000, + D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON = 0x04000000 +} D3D11_FORMAT_SUPPORT; + +typedef enum D3D11_CLEAR_FLAG +{ + D3D11_CLEAR_DEPTH = 0x0001L, + D3D11_CLEAR_STENCIL = 0x0002L +} D3D11_CLEAR_FLAG; + +typedef struct D3D11_RENDER_TARGET_BLEND_DESC +{ + BOOL BlendEnable; + D3D11_BLEND SrcBlend; + D3D11_BLEND DestBlend; + D3D11_BLEND_OP BlendOp; + D3D11_BLEND SrcBlendAlpha; + D3D11_BLEND DestBlendAlpha; + D3D11_BLEND_OP BlendOpAlpha; + UINT8 RenderTargetWriteMask; +} D3D11_RENDER_TARGET_BLEND_DESC; + +typedef struct D3D11_BLEND_DESC +{ + BOOL AlphaToCoverageEnable; + BOOL IndependentBlendEnable; + D3D11_RENDER_TARGET_BLEND_DESC RenderTarget[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT]; +} D3D11_BLEND_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_BLEND_DESC : public D3D11_BLEND_DESC {") +cpp_quote(" CD3D11_BLEND_DESC() {}") +cpp_quote(" explicit CD3D11_BLEND_DESC(const D3D11_BLEND_DESC &o) : D3D11_BLEND_DESC(o) {}") +cpp_quote(" explicit CD3D11_BLEND_DESC(CD3D11_DEFAULT) {") +cpp_quote(" AlphaToCoverageEnable = FALSE;") +cpp_quote(" IndependentBlendEnable = FALSE;") +cpp_quote(" for(D3D11_RENDER_TARGET_BLEND_DESC *target; target < RenderTarget+D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; target++) {") +cpp_quote(" target->BlendEnable = FALSE;") +cpp_quote(" target->SrcBlend = target->SrcBlendAlpha = D3D11_BLEND_ONE;") +cpp_quote(" target->DestBlend = target->DestBlendAlpha = D3D11_BLEND_ZERO;") +cpp_quote(" target->BlendOp = target->BlendOpAlpha = D3D11_BLEND_OP_ADD;") +cpp_quote(" target->RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;") +cpp_quote(" }") +cpp_quote(" }") +cpp_quote(" ~CD3D11_BLEND_DESC() {}") +cpp_quote(" operator const D3D11_BLEND_DESC&() const { return *this; }") +cpp_quote("};" ) +cpp_quote("#endif" ) + +typedef struct D3D11_BUFFER_DESC +{ + UINT ByteWidth; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; + UINT StructureByteStride; +} D3D11_BUFFER_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_BUFFER_DESC : public D3D11_BUFFER_DESC {") +cpp_quote(" CD3D11_BUFFER_DESC() {}" ) +cpp_quote(" explicit CD3D11_BUFFER_DESC(const D3D11_BUFFER_DESC &o) : D3D11_BUFFER_DESC(o) {}") +cpp_quote(" explicit CD3D11_BUFFER_DESC(UINT byteWidth,UINT bindFlags,") +cpp_quote(" D3D11_USAGE usage = D3D11_USAGE_DEFAULT, UINT cpuaccessFlags = 0,") +cpp_quote(" UINT miscFlags = 0, UINT structureByteStride = 0 ) {") +cpp_quote(" ByteWidth = byteWidth;") +cpp_quote(" Usage = usage;") +cpp_quote(" BindFlags = bindFlags;") +cpp_quote(" CPUAccessFlags = cpuaccessFlags;") +cpp_quote(" MiscFlags = miscFlags;" ) +cpp_quote(" StructureByteStride = structureByteStride;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_BUFFER_DESC() {}") +cpp_quote(" operator const D3D11_BUFFER_DESC&() const { return *this; }") +cpp_quote("};" ) +cpp_quote("#endif" ) + +typedef struct D3D11_DEPTH_STENCIL_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_DSV_DIMENSION ViewDimension; + UINT Flags; + + union + { + D3D11_TEX1D_DSV Texture1D; + D3D11_TEX1D_ARRAY_DSV Texture1DArray; + D3D11_TEX2D_DSV Texture2D; + D3D11_TEX2D_ARRAY_DSV Texture2DArray; + D3D11_TEX2DMS_DSV Texture2DMS; + D3D11_TEX2DMS_ARRAY_DSV Texture2DMSArray; + }; +} D3D11_DEPTH_STENCIL_VIEW_DESC; + +typedef struct D3D11_DEPTH_STENCILOP_DESC +{ + D3D11_STENCIL_OP StencilFailOp; + D3D11_STENCIL_OP StencilDepthFailOp; + D3D11_STENCIL_OP StencilPassOp; + D3D11_COMPARISON_FUNC StencilFunc; +} D3D11_DEPTH_STENCILOP_DESC; + +typedef struct D3D11_DEPTH_STENCIL_DESC +{ + BOOL DepthEnable; + D3D11_DEPTH_WRITE_MASK DepthWriteMask; + D3D11_COMPARISON_FUNC DepthFunc; + BOOL StencilEnable; + UINT8 StencilReadMask; + UINT8 StencilWriteMask; + D3D11_DEPTH_STENCILOP_DESC FrontFace; + D3D11_DEPTH_STENCILOP_DESC BackFace; +} D3D11_DEPTH_STENCIL_DESC; + +typedef struct D3D11_RENDER_TARGET_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_RTV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_RTV Buffer; + D3D11_TEX1D_RTV Texture1D; + D3D11_TEX1D_ARRAY_RTV Texture1DArray; + D3D11_TEX2D_RTV Texture2D; + D3D11_TEX2D_ARRAY_RTV Texture2DArray; + D3D11_TEX2DMS_RTV Texture2DMS; + D3D11_TEX2DMS_ARRAY_RTV Texture2DMSArray; + D3D11_TEX3D_RTV Texture3D; + }; +} D3D11_RENDER_TARGET_VIEW_DESC; + +typedef struct D3D11_SAMPLER_DESC +{ + D3D11_FILTER Filter; + D3D11_TEXTURE_ADDRESS_MODE AddressU; + D3D11_TEXTURE_ADDRESS_MODE AddressV; + D3D11_TEXTURE_ADDRESS_MODE AddressW; + FLOAT MipLODBias; + UINT MaxAnisotropy; + D3D11_COMPARISON_FUNC ComparisonFunc; + FLOAT BorderColor[4]; + FLOAT MinLOD; + FLOAT MaxLOD; +} D3D11_SAMPLER_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_SAMPLER_DESC : public D3D11_SAMPLER_DESC {") +cpp_quote(" CD3D11_SAMPLER_DESC() {}") +cpp_quote(" explicit CD3D11_SAMPLER_DESC(const D3D11_SAMPLER_DESC &o) : D3D11_SAMPLER_DESC(o) {}") +cpp_quote(" explicit CD3D11_SAMPLER_DESC(CD3D11_DEFAULT) {" ) +cpp_quote(" Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;") +cpp_quote(" AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;") +cpp_quote(" AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;") +cpp_quote(" AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;") +cpp_quote(" MipLODBias = 0;") +cpp_quote(" MaxAnisotropy = 1;") +cpp_quote(" ComparisonFunc = D3D11_COMPARISON_NEVER;") +cpp_quote(" BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 1.0f;") +cpp_quote(" MinLOD = -3.402823466e+38f;") +cpp_quote(" MaxLOD = 3.402823466e+38f;") +cpp_quote(" }") +cpp_quote(" explicit CD3D11_SAMPLER_DESC(D3D11_FILTER filter, D3D11_TEXTURE_ADDRESS_MODE addressU,") +cpp_quote(" D3D11_TEXTURE_ADDRESS_MODE addressV, D3D11_TEXTURE_ADDRESS_MODE addressW,") +cpp_quote(" FLOAT mipLODBias, UINT maxAnisotropy, D3D11_COMPARISON_FUNC comparisonFunc,") +cpp_quote(" const FLOAT *borderColor, FLOAT minLOD, FLOAT maxLOD) {" ) +cpp_quote(" Filter = filter;") +cpp_quote(" AddressU = addressU;") +cpp_quote(" AddressV = addressV;") +cpp_quote(" AddressW = addressW;") +cpp_quote(" MipLODBias = mipLODBias;") +cpp_quote(" MaxAnisotropy = maxAnisotropy;") +cpp_quote(" ComparisonFunc = comparisonFunc;") +cpp_quote(" if(borderColor) {") +cpp_quote(" BorderColor[0] = borderColor[0];") +cpp_quote(" BorderColor[1] = borderColor[1];") +cpp_quote(" BorderColor[2] = borderColor[2];") +cpp_quote(" BorderColor[3] = borderColor[3];") +cpp_quote(" }else {") +cpp_quote(" BorderColor[0] = BorderColor[1] = BorderColor[2] = BorderColor[3] = 1.0f;") +cpp_quote(" }") +cpp_quote(" MinLOD = minLOD;") +cpp_quote(" MaxLOD = maxLOD;") +cpp_quote(" }") +cpp_quote(" ~CD3D11_SAMPLER_DESC() {}") +cpp_quote(" operator const D3D11_SAMPLER_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_SHADER_RESOURCE_VIEW_DESC +{ + DXGI_FORMAT Format; + D3D11_SRV_DIMENSION ViewDimension; + + union + { + D3D11_BUFFER_SRV Buffer; + D3D11_TEX1D_SRV Texture1D; + D3D11_TEX1D_ARRAY_SRV Texture1DArray; + D3D11_TEX2D_SRV Texture2D; + D3D11_TEX2D_ARRAY_SRV Texture2DArray; + D3D11_TEX2DMS_SRV Texture2DMS; + D3D11_TEX2DMS_ARRAY_SRV Texture2DMSArray; + D3D11_TEX3D_SRV Texture3D; + D3D11_TEXCUBE_SRV TextureCube; + D3D11_TEXCUBE_ARRAY_SRV TextureCubeArray; + D3D11_BUFFEREX_SRV BufferEx; + }; +} D3D11_SHADER_RESOURCE_VIEW_DESC; + +typedef struct D3D11_TEXTURE1D_DESC +{ + UINT Width; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D11_TEXTURE1D_DESC; + +typedef struct D3D11_TEXTURE2D_DESC +{ + UINT Width; + UINT Height; + UINT MipLevels; + UINT ArraySize; + DXGI_FORMAT Format; + DXGI_SAMPLE_DESC SampleDesc; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D11_TEXTURE2D_DESC; + +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_TEXTURE2D_DESC : public D3D11_TEXTURE2D_DESC {") +cpp_quote(" CD3D11_TEXTURE2D_DESC() {}") +cpp_quote(" explicit CD3D11_TEXTURE2D_DESC(const D3D11_TEXTURE2D_DESC &o) : D3D11_TEXTURE2D_DESC(o) {}") +cpp_quote(" explicit CD3D11_TEXTURE2D_DESC(DXGI_FORMAT format, UINT width, UINT height, UINT arraySize = 1,") +cpp_quote(" UINT mipLevels = 0, UINT bindFlags = D3D11_BIND_SHADER_RESOURCE,") +cpp_quote(" D3D11_USAGE usage = D3D11_USAGE_DEFAULT, UINT cpuaccessFlags = 0, UINT sampleCount = 1," ) +cpp_quote(" UINT sampleQuality = 0, UINT miscFlags = 0) {") +cpp_quote(" Width = width;") +cpp_quote(" Height = height;") +cpp_quote(" MipLevels = mipLevels;") +cpp_quote(" ArraySize = arraySize;") +cpp_quote(" Format = format;") +cpp_quote(" SampleDesc.Count = sampleCount;") +cpp_quote(" SampleDesc.Quality = sampleQuality;") +cpp_quote(" Usage = usage;") +cpp_quote(" BindFlags = bindFlags;") +cpp_quote(" CPUAccessFlags = cpuaccessFlags;") +cpp_quote(" MiscFlags = miscFlags;") +cpp_quote(" }" ) +cpp_quote(" ~CD3D11_TEXTURE2D_DESC() {}") +cpp_quote(" operator const D3D11_TEXTURE2D_DESC&() const { return *this; }") +cpp_quote("};") +cpp_quote("#endif") + +typedef struct D3D11_TEXTURE3D_DESC +{ + UINT Width; + UINT Height; + UINT Depth; + UINT MipLevels; + DXGI_FORMAT Format; + D3D11_USAGE Usage; + UINT BindFlags; + UINT CPUAccessFlags; + UINT MiscFlags; +} D3D11_TEXTURE3D_DESC; + +/* A couple forward declarations are needed */ +interface ID3D11Device; +interface ID3D11ClassLinkage; + +[ + object, + local, + uuid(1841e5c8-16b0-489b-bcc8-44cfb0d5deae) +] +interface ID3D11DeviceChild : IUnknown +{ + void GetDevice( + [out] ID3D11Device **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); +} + +[ + object, + local, + uuid(4b35d0cd-1e15-4258-9c98-1b1333f6dd3b) +] +interface ID3D11Asynchronous : ID3D11DeviceChild +{ + UINT GetDataSize(); +} + +[ + object, + local, + uuid(d6c00747-87b7-425e-b84d-44d108560afd) +] +interface ID3D11Query : ID3D11Asynchronous +{ + void GetDesc( + [out] D3D11_QUERY_DESC *pDesc); +} + +[ + object, + local, + uuid(dc8e63f3-d12b-4952-b47b-5e45026a862d) +] +interface ID3D11Resource : ID3D11DeviceChild +{ + void GetType( + [out] D3D11_RESOURCE_DIMENSION *pResourceDimension); + void SetEvictionPriority( + [in] UINT EvictionPriority); + UINT GetEvictionPriority(); +} + +[ + object, + local, + uuid(839d1216-bb2e-412b-b7f4-a9dbebe08ed1) +] +interface ID3D11View : ID3D11DeviceChild +{ + void GetResource( + [out] ID3D11Resource **ppResource); +} + +[ + object, + local, + uuid(75b68faa-347d-4159-8f45-a0640f01cd9a) +] +interface ID3D11BlendState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_BLEND_DESC *pDesc); +} + +[ + object, + local, + uuid(48570b85-d1ee-4fcd-a250-eb350722b037) +] +interface ID3D11Buffer : ID3D11Resource +{ + void GetDesc( + [out] D3D11_BUFFER_DESC *pDesc); +} + +[ + object, + local, + uuid(a6cd7faa-b0b7-4a2f-9436-8662a65797cb) +] +interface ID3D11ClassInstance : ID3D11DeviceChild +{ + void GetClassLinkage( + [out] ID3D11ClassLinkage **ppLinkage); + void GetDesc( + [out] D3D11_CLASS_INSTANCE_DESC *pDesc); + void GetInstanceName( + [out] LPSTR pInstanceName, + [in, out] SIZE_T *pBufferLength); + void GetTypeName( + [out] LPSTR pTypeName, + [in, out] SIZE_T *pBufferLength); +} + +[ + object, + local, + uuid(ddf57cba-9543-46e4-a12b-f207a0fe7fed) +] +interface ID3D11ClassLinkage : ID3D11DeviceChild +{ + HRESULT GetClassInstance( + [in] LPCSTR pClassInstanceName, + [in] UINT InstanceIndex, + [out] ID3D11ClassInstance **ppInstance); + HRESULT CreateClassInstance( + [in] LPCSTR pClassTypeName, + [in] UINT ConstantBufferOffset, + [in] UINT ConstantVectorOffset, + [in] UINT TextureOffset, + [in] UINT SamplerOffset, + [out] ID3D11ClassInstance **ppInstance); +} + +[ + object, + local, + uuid(a24bc4d1-769e-43f7-8013-98ff566c18e2) +] +interface ID3D11CommandList : ID3D11DeviceChild +{ + UINT GetContextFlags(); +} + +[ + object, + local, + uuid(4f5b196e-c2bd-495e-bd01-1fded38e4969) +] +interface ID3D11ComputeShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(6e8c49fb-a371-4770-b440-29086022b741) +] +interface ID3D11Counter : ID3D11Asynchronous +{ + void GetDesc( + [out] D3D11_COUNTER_DESC *pDesc); +} + +[ + object, + local, + uuid(03823efb-8d8f-4e1c-9aa2-f64bb2cbfdf1) +] +interface ID3D11DepthStencilState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_DEPTH_STENCIL_DESC *pDesc); +} + +[ + object, + local, + uuid(9fdac92a-1876-48c3-afad-25b94f84a9b6) +] +interface ID3D11DepthStencilView : ID3D11View +{ + void GetDesc( + [out] D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(f582c508-0f36-490c-9977-31eece268cfa) +] +interface ID3D11DomainShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(38325b96-effb-4022-ba02-2e795b70275c) +] +interface ID3D11GeometryShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(8e5c6061-628a-4c8e-8264-bbe45cb3d5dd) +] +interface ID3D11HullShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(e4819ddc-4cf0-4025-bd26-5de82a3e07b7) +] +interface ID3D11InputLayout : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(ea82e40d-51dc-4f33-93d4-db7c9125ae8c) +] +interface ID3D11PixelShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(9eb576dd-9f77-4d86-81aa-8bab5fe490e2) +] +interface ID3D11Predicate : ID3D11Query +{ +} + +[ + object, + local, + uuid(9bb4ab81-ab1a-4d8f-b506-fc04200b6ee7) +] +interface ID3D11RasterizerState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_RASTERIZER_DESC *pDesc); +} + +[ + object, + local, + uuid(dfdba067-0b8d-4865-875b-d7b4516cc164) +] +interface ID3D11RenderTargetView : ID3D11View +{ + void GetDesc( + [out] D3D11_RENDER_TARGET_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(da6fea51-564c-4487-9810-f0d0f9b4e3a5) +] +interface ID3D11SamplerState : ID3D11DeviceChild +{ + void GetDesc( + [out] D3D11_SAMPLER_DESC *pDesc); +} + +[ + object, + local, + uuid(b0e06fe0-8192-4e1a-b1ca-36d7414710b2) +] +interface ID3D11ShaderResourceView : ID3D11View +{ + void GetDesc( + [out] D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(f8fb5c27-c6b3-4f75-a4c8-439af2ef564c), +] +interface ID3D11Texture1D : ID3D11Resource +{ + void GetDesc( + [out] D3D11_TEXTURE1D_DESC *pDesc); +} + +[ + object, + local, + uuid(6f15aaf2-d208-4e89-9ab4-489535d34f9c) +] +interface ID3D11Texture2D : ID3D11Resource +{ + void GetDesc( + [out] D3D11_TEXTURE2D_DESC *pDesc); +} + +[ + object, + local, + uuid(037e866e-f56d-4357-a8af-9dabbe6e250e) +] +interface ID3D11Texture3D : ID3D11Resource +{ + void GetDesc( + [out] D3D11_TEXTURE3D_DESC *pDesc); +} + +[ + object, + local, + uuid(28acf509-7f5c-48f6-8611-f316010a6380) +] +interface ID3D11UnorderedAccessView : ID3D11View +{ + void GetDesc( + [out] D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc); +} + +[ + object, + local, + uuid(3b301d64-d678-4289-8897-22f8928b72f3) +] +interface ID3D11VertexShader : ID3D11DeviceChild +{ +} + +[ + object, + local, + uuid(c0bfa96c-e089-44fb-8eaf-26f8796190da) +] +interface ID3D11DeviceContext : ID3D11DeviceChild +{ + void VSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void PSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void PSSetShader( + [in] ID3D11PixelShader *pPixelShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void PSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void VSSetShader( + [in] ID3D11VertexShader *pVertexShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void DrawIndexed( + [in] UINT IndexCount, + [in] UINT StartIndexLocation, + [in] INT BaseVertexLocation); + void Draw( + [in] UINT VertexCount, + [in] UINT StartVertexLocation); + HRESULT Map( + [in] ID3D11Resource *pResource, + [in] UINT Subresource, + [in] D3D11_MAP MapType, + [in] UINT MapFlags, + [out] D3D11_MAPPED_SUBRESOURCE *pMappedResource); + void Unmap( + [in] ID3D11Resource *pResource, + [in] UINT Subresource); + void PSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void IASetInputLayout( + [in] ID3D11InputLayout *pInputLayout); + void IASetVertexBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppVertexBuffers, + [in] const UINT *pStrides, + [in] const UINT *pOffsets); + void IASetIndexBuffer( + [in] ID3D11Buffer *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] ID3D11Buffer *const *ppConstantBuffers); + void GSSetShader( + [in] ID3D11GeometryShader *pShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void IASetPrimitiveTopology( + [in] D3D11_PRIMITIVE_TOPOLOGY Topology); + void VSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void VSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void Begin( + [in] ID3D11Asynchronous *pAsync); + void End( + [in] ID3D11Asynchronous *pAsync); + HRESULT GetData( + [in] ID3D11Asynchronous *pAsync, + [in] void *pData, + [in] UINT DataSize, + [in] UINT GetDataFlags); + void SetPredication( + [in] ID3D11Predicate *pPredicate, + [in] BOOL PredicateValue); + void GSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void GSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void OMSetRenderTargets( + [in] UINT NumViews, + [in] ID3D11RenderTargetView *const *ppRenderTargetViews, + [in] ID3D11DepthStencilView *pDepthStencilView); + void OMSetRenderTargetsAndUnorderedAccessViews( + [in] UINT NumRTVs, + [in] ID3D11RenderTargetView *const *ppRenderTargetViews, + [in] ID3D11DepthStencilView *pDepthStencilView, + [in] UINT UAVStartSlot, + [in] UINT NumUAVs, + [in] ID3D11UnorderedAccessView *const *ppUnorderedAccessViews, + [in] const UINT *pUAVInitialCounts); + void OMSetBlendState( + [in] ID3D11BlendState *pBlendState, + [in] const FLOAT BlendFactor[4], + [in] UINT SampleMask); + void OMSetDepthStencilState( + [in] ID3D11DepthStencilState *pDepthStencilState, + [in] UINT StencilRef); + void SOSetTargets( + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppSOTargets, + [in] const UINT *pOffsets); + void DrawAuto(); + void DrawIndexedInstancedIndirect( + [in] ID3D11Buffer *pBufferForArgs, + [in] UINT AlignedByteOffsetForArgs); + void DrawInstancedIndirect( + [in] ID3D11Buffer *pBufferForArgs, + [in] UINT AlignedByteOffsetForArgs); + void Dispatch( + [in] UINT ThreadGroupCountX, + [in] UINT ThreadGroupCountY, + [in] UINT ThreadGroupCountZ); + void DispatchIndirect( + [in] ID3D11Buffer *pBufferForArgs, + [in] UINT AlignedByteOffsetForArgs); + void RSSetState( + [in] ID3D11RasterizerState *pRasterizerState); + void RSSetViewports( + [in] UINT NumViewports, + [in] const D3D11_VIEWPORT *pViewports); + void RSSetScissorRects( + [in] UINT NumRects, + [in] const D3D11_RECT *pRects); + void CopySubresourceRegion( + [in] ID3D11Resource *pDstResource, + [in] UINT DstSubresource, + [in] UINT DstX, + [in] UINT DstY, + [in] UINT DstZ, + [in] ID3D11Resource *pSrcResource, + [in] UINT SrcSubresource, + [in] const D3D11_BOX *pSrcBox); + void CopyResource( + [in] ID3D11Resource *pDstResource, + [in] ID3D11Resource *pSrcResource); + void UpdateSubresource( + [in] ID3D11Resource *pDstResource, + [in] UINT DstSubresource, + [in] const D3D11_BOX *pDstBox, + [in] const void *pSrcData, + [in] UINT SrcRowPitch, + [in] UINT SrcDepthPitch); + void CopyStructureCount( + [in] ID3D11Buffer *pDstBuffer, + [in] UINT DstAlignedByteOffset, + [in] ID3D11UnorderedAccessView *pSrcView); + void ClearRenderTargetView( + [in] ID3D11RenderTargetView *pRenderTargetView, + [in] const FLOAT ColorRGBA[4]); + void ClearUnorderedAccessViewUint( + [in] ID3D11UnorderedAccessView *pUnorderedAccessView, + [in] const UINT Values[4]); + void ClearUnorderedAccessViewFloat( + [in] ID3D11UnorderedAccessView *pUnorderedAccessView, + [in] const FLOAT Values[4]); + void ClearDepthStencilView( + [in] ID3D11DepthStencilView *pDepthStencilView, + [in] UINT ClearFlags, + [in] FLOAT Depth, + [in] UINT8 Stencil); + void GenerateMips( + [in] ID3D11ShaderResourceView *pShaderResourceView); + void SetResourceMinLOD( + [in] ID3D11Resource *pResource, FLOAT MinLOD); + FLOAT GetResourceMinLOD( + [in] ID3D11Resource *pResource); + void ResolveSubresource( + [in] ID3D11Resource *pDstResource, + [in] UINT DstSubresource, + [in] ID3D11Resource *pSrcResource, + [in] UINT SrcSubresource, + [in] DXGI_FORMAT Format); + void ExecuteCommandList( + [in] ID3D11CommandList *pCommandList, + BOOL RestoreContextState); + void HSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void HSSetShader( + [in] ID3D11HullShader *pHullShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void HSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void HSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void DSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void DSSetShader( + [in] ID3D11DomainShader *pDomainShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void DSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void DSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void CSSetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [in] ID3D11ShaderResourceView *const *ppShaderResourceViews); + void CSSetUnorderedAccessViews( + [in] UINT StartSlot, + [in] UINT NumUAVs, + [in] ID3D11UnorderedAccessView *const *ppUnorderedAccessViews, + [in] const UINT *pUAVInitialCounts); + void CSSetShader( + [in] ID3D11ComputeShader *pComputeShader, + [in] ID3D11ClassInstance *const *ppClassInstances, + UINT NumClassInstances); + void CSSetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [in] ID3D11SamplerState *const *ppSamplers); + void CSSetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [in] ID3D11Buffer *const *ppConstantBuffers); + void VSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void PSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void PSGetShader( + [out] ID3D11PixelShader **ppPixelShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void PSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void VSGetShader( + [out] ID3D11VertexShader **ppVertexShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void PSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void IAGetInputLayout( + [out] ID3D11InputLayout **ppInputLayout); + void IAGetVertexBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppVertexBuffers, + [out] UINT *pStrides, + [out] UINT *pOffsets); + void IAGetIndexBuffer( + [out] ID3D11Buffer **pIndexBuffer, + [out] DXGI_FORMAT* Format, + [out] UINT* Offset); + void GSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void GSGetShader( + [out] ID3D11GeometryShader **ppGeometryShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void IAGetPrimitiveTopology( + [out] D3D11_PRIMITIVE_TOPOLOGY *pTopology); + void VSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void VSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void GetPredication( + [out] ID3D11Predicate **ppPredicate, + [out] BOOL *pPredicateValue); + void GSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void GSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void OMGetRenderTargets( + [in] UINT NumViews, + [out] ID3D11RenderTargetView **ppRenderTargetViews, + [out] ID3D11DepthStencilView **ppDepthStencilView); + void OMGetRenderTargetsAndUnorderedAccessViews( + [in] UINT NumRTVs, + [out] ID3D11RenderTargetView **ppRenderTargetViews, + [out] ID3D11DepthStencilView **ppDepthStencilView, + [in] UINT UAVStartSlot, + [out] UINT NumUAVs, + [out] ID3D11UnorderedAccessView **ppUnorderedAccessViews); + void OMGetBlendState( + [out] ID3D11BlendState **ppBlendState, + [out] FLOAT BlendFactor[4], + [out] UINT *pSampleMask); + void OMGetDepthStencilState( + [out] ID3D11DepthStencilState **ppDepthStencilState, + [out] UINT *pStencilRef); + void SOGetTargets( + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppSOTargets); + void RSGetState( + [out] ID3D11RasterizerState **ppRasterizerState); + void RSGetViewports( + [in, out] UINT *pNumViewports, + [out] D3D11_VIEWPORT *pViewports); + void RSGetScissorRects( + [in, out] UINT *pNumRects, + [out] D3D11_RECT *pRects); + void HSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void HSGetShader( + [out] ID3D11HullShader **ppHullShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void HSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void HSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void DSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void DSGetShader( + [out] ID3D11DomainShader **ppDomainShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void DSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void DSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void CSGetShaderResources( + [in] UINT StartSlot, + [in] UINT NumViews, + [out] ID3D11ShaderResourceView **ppShaderResourceViews); + void CSGetUnorderedAccessViews( + [in] UINT StartSlot, + [in] UINT NumUAVs, + [out] ID3D11UnorderedAccessView **ppUnorderedAccessViews); + void CSGetShader( + [out] ID3D11ComputeShader **ppComputeShader, + [out] ID3D11ClassInstance **ppClassInstances, + [in, out] UINT *pNumClassInstances); + void CSGetSamplers( + [in] UINT StartSlot, + [in] UINT NumSamplers, + [out] ID3D11SamplerState **ppSamplers); + void CSGetConstantBuffers( + [in] UINT StartSlot, + [in] UINT NumBuffers, + [out] ID3D11Buffer **ppConstantBuffers); + void ClearState(); + void Flush(); + D3D11_DEVICE_CONTEXT_TYPE GetType(); + UINT GetContextFlags(); + HRESULT FinishCommandList( + BOOL RestoreDeferredContextState, + [out] ID3D11CommandList **ppCommandList); +} + +[ + object, + local, + uuid(db6f6ddb-ac77-4e88-8253-819df9bbf140) +] +interface ID3D11Device : IUnknown +{ + HRESULT CreateBuffer( + [in] const D3D11_BUFFER_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Buffer **ppBuffer); + HRESULT CreateTexture1D( + [in] const D3D11_TEXTURE1D_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Texture1D **ppTexture1D); + HRESULT CreateTexture2D( + [in] const D3D11_TEXTURE2D_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Texture2D **ppTexture2D); + HRESULT CreateTexture3D( + [in] const D3D11_TEXTURE3D_DESC *pDesc, + [in] const D3D11_SUBRESOURCE_DATA *pInitialData, + [out] ID3D11Texture3D **ppTexture3D); + HRESULT CreateShaderResourceView( + [in] ID3D11Resource *pResource, + [in] const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc, + [out] ID3D11ShaderResourceView **ppSRView); + HRESULT CreateUnorderedAccessView( + [in] ID3D11Resource *pResource, + [in] const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc, + [out] ID3D11UnorderedAccessView **ppUAView); + HRESULT CreateRenderTargetView( + [in] ID3D11Resource *pResource, + [in] const D3D11_RENDER_TARGET_VIEW_DESC *pDesc, + [out] ID3D11RenderTargetView **ppRTView); + HRESULT CreateDepthStencilView( + [in] ID3D11Resource *pResource, + [in] const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc, + [out] ID3D11DepthStencilView **ppDepthStencilView); + HRESULT CreateInputLayout( + [in] const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs, + [in] UINT NumElements, + [in] const void *pShaderBytecodeWithInputSignature, + [in] SIZE_T BytecodeLength, + [out] ID3D11InputLayout **ppInputLayout); + HRESULT CreateVertexShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11VertexShader **ppVertexShader); + HRESULT CreateGeometryShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11GeometryShader **ppGeometryShader); + HRESULT CreateGeometryShaderWithStreamOutput( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] const D3D11_SO_DECLARATION_ENTRY *pSODeclaration, + [in] UINT NumEntries, + [in] const UINT *pBufferStrides, + [in] UINT NumStrides, + [in] UINT RasterizedStream, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11GeometryShader **ppGeometryShader); + HRESULT CreatePixelShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11PixelShader **ppPixelShader); + HRESULT CreateHullShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11HullShader **ppHullShader); + HRESULT CreateDomainShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11DomainShader **ppDomainShader); + HRESULT CreateComputeShader( + [in] const void *pShaderBytecode, + [in] SIZE_T BytecodeLength, + [in] ID3D11ClassLinkage *pClassLinkage, + [out] ID3D11ComputeShader **ppComputeShader); + HRESULT CreateClassLinkage( + [out] ID3D11ClassLinkage **ppLinkage); + HRESULT CreateBlendState( + [in] const D3D11_BLEND_DESC *pBlendStateDesc, + [out] ID3D11BlendState **ppBlendState); + HRESULT CreateDepthStencilState( + [in] const D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc, + [out] ID3D11DepthStencilState **ppDepthStencilState); + HRESULT CreateRasterizerState( + [in] const D3D11_RASTERIZER_DESC *pRasterizerDesc, + [out] ID3D11RasterizerState **ppRasterizerState); + HRESULT CreateSamplerState( + [in] const D3D11_SAMPLER_DESC *pSamplerDesc, + [out] ID3D11SamplerState **ppSamplerState); + HRESULT CreateQuery( + [in] const D3D11_QUERY_DESC *pQueryDesc, + [out] ID3D11Query **ppQuery); + HRESULT CreatePredicate( + [in] const D3D11_QUERY_DESC *pPredicateDesc, + [out] ID3D11Predicate **ppPredicate); + HRESULT CreateCounter( + [in] const D3D11_COUNTER_DESC *pCounterDesc, + [out] ID3D11Counter **ppCounter); + HRESULT CreateDeferredContext( + UINT ContextFlags, + [out] ID3D11DeviceContext **ppDeferredContext); + HRESULT OpenSharedResource( + [in] HANDLE hResource, + [in] REFIID ReturnedInterface, + [out] void **ppResource); + HRESULT CheckFormatSupport( + [in] DXGI_FORMAT Format, + [out] UINT *pFormatSupport); + HRESULT CheckMultisampleQualityLevels( + [in] DXGI_FORMAT Format, + [in] UINT SampleCount, + [out] UINT *pNumQualityLevels); + void CheckCounterInfo( + [out] D3D11_COUNTER_INFO *pCounterInfo); + HRESULT CheckCounter( + [in] const D3D11_COUNTER_DESC *pDesc, + [out] D3D11_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); + HRESULT CheckFeatureSupport( + D3D11_FEATURE Feature, + [out] void *pFeatureSupportData, + UINT FeatureSupportDataSize); + 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); + D3D_FEATURE_LEVEL GetFeatureLevel(); + UINT GetCreationFlags(); + HRESULT GetDeviceRemovedReason(); + void GetImmediateContext( + [out] ID3D11DeviceContext **ppImmediateContext); + HRESULT SetExceptionMode(UINT RaiseFlags); + UINT GetExceptionMode(); +} + +typedef enum D3D11_CREATE_DEVICE_FLAG { + D3D11_CREATE_DEVICE_SINGLETHREADED = 0x0001, + D3D11_CREATE_DEVICE_DEBUG = 0x0002, + D3D11_CREATE_DEVICE_SWITCH_TO_REF = 0x0004, + D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x0008, + D3D11_CREATE_DEVICE_BGRA_SUPPORT = 0x0020, + D3D11_CREATE_DEVICE_DEBUGGABLE = 0x0040, + D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x0080, + D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT = 0x0100, + D3D11_CREATE_DEVICE_VIDEO_SUPPORT = 0x0800 +} D3D11_CREATE_DEVICE_FLAG; + +const UINT D3D11_SDK_VERSION = 7; + +cpp_quote("#include <d3d10_1.h>") +cpp_quote("#ifndef D3D11_IGNORE_SDK_LAYERS") +cpp_quote("# include <d3d11sdklayers.h>") +cpp_quote("#endif") +cpp_quote("#include <d3d10misc.h>") +cpp_quote("#include <d3d10shader.h>") +cpp_quote("#include <d3d10effect.h>") +cpp_quote("#include <d3d10_1shader.h>") + +cpp_quote("typedef HRESULT (WINAPI* PFN_D3D11_CREATE_DEVICE)(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,") +cpp_quote(" const D3D_FEATURE_LEVEL*,UINT,UINT,ID3D11Device**,D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);") + +cpp_quote("HRESULT WINAPI D3D11CreateDevice(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,const D3D_FEATURE_LEVEL*," ) +cpp_quote(" UINT,UINT,ID3D11Device**,D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);") + +cpp_quote("typedef HRESULT (WINAPI *PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,") +cpp_quote(" const D3D_FEATURE_LEVEL*,UINT,UINT,const DXGI_SWAP_CHAIN_DESC*,IDXGISwapChain**,ID3D11Device**,") +cpp_quote(" D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);") |