reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-25 12:49:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
16c8ca8082
wine/include/d3d11.idl
Jacek Caban 4de32753a2 d3d11.idl: Added some missing declarations.
2013-09-11 16:09:25 +02:00

2002 lines
62 KiB
Plaintext
Raw Blame History

/*
* 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
*/
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("/* FIXME: # 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**);")
Reference in New Issue View Git Blame Copy Permalink