include: Flesh out d3d11.idl.

include/d3d11.idl

 /*
  * 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
@@ -21,6 +22,1628 @@ 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 unsigned int D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT = 8;
+
+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
+{
+    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 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;
+
+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;
+
+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 struct D3D11_VIEWPORT
+{
+    FLOAT TopLeftX;
+    FLOAT TopLeftY;
+    FLOAT Width;
+    FLOAT Height;
+    FLOAT MinDepth;
+    FLOAT MaxDepth;
+} D3D11_VIEWPORT;
+
+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;
+
+typedef struct D3D11_BUFFER_DESC
+{
+    UINT ByteWidth;
+    D3D11_USAGE Usage;
+    UINT BindFlags;
+    UINT CPUAccessFlags;
+    UINT MiscFlags;
+    UINT StructureByteStride;
+} D3D11_BUFFER_DESC;
+
+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;
+
+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;
+
+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();
+}
+
 cpp_quote("#include <d3d10_1.h>")
 cpp_quote("#ifndef D3D11_IGNORE_SDK_LAYERS")
 cpp_quote("/* FIXME: # include <d3d11sdklayers.h> */")
@@ -29,10 +1652,3 @@ cpp_quote("#include <d3d10misc.h>")
 cpp_quote("#include <d3d10shader.h>")
 cpp_quote("#include <d3d10effect.h>")
 cpp_quote("#include <d3d10_1shader.h>")
-
-
-typedef D3D_SRV_DIMENSION D3D11_SRV_DIMENSION;
-
-typedef D3D_PRIMITIVE D3D11_PRIMITIVE;
-
-typedef D3D_PRIMITIVE_TOPOLOGY D3D11_PRIMITIVE_TOPOLOGY;