mingw-w64-headers/direct-x/include/d3d11_1.idl

/*
 * Copyright 2014 Jacek Caban for CodeWeavers
 *
 * 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 "dxgi1_2.idl";
import "d3dcommon.idl";
import "d3d11.idl";

typedef enum D3D11_LOGIC_OP {
    D3D11_LOGIC_OP_CLEAR = 0,
    D3D11_LOGIC_OP_SET,
    D3D11_LOGIC_OP_COPY,
    D3D11_LOGIC_OP_COPY_INVERTED,
    D3D11_LOGIC_OP_NOOP,
    D3D11_LOGIC_OP_INVERT,
    D3D11_LOGIC_OP_AND,
    D3D11_LOGIC_OP_NAND,
    D3D11_LOGIC_OP_OR,
    D3D11_LOGIC_OP_NOR,
    D3D11_LOGIC_OP_XOR,
    D3D11_LOGIC_OP_EQUIV,
    D3D11_LOGIC_OP_AND_REVERSE,
    D3D11_LOGIC_OP_AND_INVERTED,
    D3D11_LOGIC_OP_OR_REVERSE,
    D3D11_LOGIC_OP_OR_INVERTED
} D3D11_LOGIC_OP;

typedef struct _D3D11_RENDER_TARGET_BLEND_DESC1 {
    BOOL           BlendEnable;
    BOOL           LogicOpEnable;
    D3D11_BLEND    SrcBlend;
    D3D11_BLEND    DestBlend;
    D3D11_BLEND_OP BlendOp;
    D3D11_BLEND    SrcBlendAlpha;
    D3D11_BLEND    DestBlendAlpha;
    D3D11_BLEND_OP BlendOpAlpha;
    D3D11_LOGIC_OP LogicOp;
    UINT8          RenderTargetWriteMask;
} D3D11_RENDER_TARGET_BLEND_DESC1;

typedef struct _D3D11_BLEND_DESC1 {
    BOOL                            AlphaToCoverageEnable;
    BOOL                            IndependentBlendEnable;
    D3D11_RENDER_TARGET_BLEND_DESC1 RenderTarget[D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT];
} D3D11_BLEND_DESC1;

typedef struct _D3D11_RASTERIZER_DESC1 {
    D3D11_FILL_MODE FillMode;
    D3D11_CULL_MODE CullMode;
    BOOL            FrontCounterClockwise;
    INT             DepthBias;
    FLOAT           DepthBiasClamp;
    FLOAT           SlopeScaledDepthBias;
    BOOL            DepthClipEnable;
    BOOL            ScissorEnable;
    BOOL            MultisampleEnable;
    BOOL            AntialiasedLineEnable;
    UINT            ForcedSampleCount;
} D3D11_RASTERIZER_DESC1;

[
    uuid(cc86fabe-da55-401d-85e7-e3c9de2877e9),
    object,
    local,
    pointer_default(unique)
]
interface ID3D11BlendState1 : ID3D11BlendState
{
    void GetDesc1(D3D11_BLEND_DESC1 *pDesc);
}

[
    uuid(5c1e0d8a-7c23-48f9-8c59-a92958ceff11),
    object,
    local,
    pointer_default(unique)
]
interface ID3DDeviceContextState : ID3D11DeviceChild
{
}

[
    uuid(bb2c6faa-b5fb-4082-8e6b-388b8cfa90e1),
    object,
    local,
    pointer_default(unique)
]
interface ID3D11DeviceContext1 : ID3D11DeviceContext
{
    void CopySubresourceRegion1(
            ID3D11Resource *pDstResource,
            UINT DstSubresource,
            UINT DstX,
            UINT DstY,
            UINT DstZ,
            ID3D11Resource *pSrcResource,
            UINT SrcSubresource,
            const D3D11_BOX *pSrcBox,
            UINT CopyFlags);

    void UpdateSubresource1(
            ID3D11Resource *pDstResource,
            UINT DstSubresource,
            const D3D11_BOX *pDstBox,
            const void *pSrcData,
            UINT SrcRowPitch,
            UINT SrcDepthPitch,
            UINT CopyFlags);

    void DiscardResource(ID3D11Resource *pResource);

    void DiscardView(ID3D11View *pResourceView);

    void VSSetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer *const *ppConstantBuffers,
            const UINT *pFirstConstant,
            const UINT *pNumConstants);

    void HSSetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer *const *ppConstantBuffers,
            const UINT *pFirstConstant,
            const UINT *pNumConstants);

    void DSSetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer *const *ppConstantBuffers,
            const UINT *pFirstConstant,
            const UINT *pNumConstants);

    void GSSetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer *const *ppConstantBuffers,
            const UINT *pFirstConstant,
            const UINT *pNumConstants);

    void PSSetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer *const *ppConstantBuffers,
            const UINT *pFirstConstant,
            const UINT *pNumConstants);

    void CSSetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer *const *ppConstantBuffers,
            const UINT *pFirstConstant,
            const UINT *pNumConstants);

    void VSGetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer **ppConstantBuffers,
            UINT *pFirstConstant,
            UINT *pNumConstants);

    void HSGetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer **ppConstantBuffers,
            UINT *pFirstConstant,
            UINT *pNumConstants);

    void DSGetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer **ppConstantBuffers,
            UINT *pFirstConstant,
            UINT *pNumConstants);

    void GSGetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer **ppConstantBuffers,
            UINT *pFirstConstant,
            UINT *pNumConstants);

    void PSGetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer **ppConstantBuffers,
            UINT *pFirstConstant,
            UINT *pNumConstants);

    void CSGetConstantBuffers1(
            UINT StartSlot,
            UINT NumBuffers,
            ID3D11Buffer **ppConstantBuffers,
            UINT *pFirstConstant,
            UINT *pNumConstants);

    void SwapDeviceContextState(
            ID3DDeviceContextState *pState,
            ID3DDeviceContextState **ppPreviousState);

    void ClearView(
            ID3D11View *pView,
            FLOAT Color[4],
            const D3D11_RECT *pRect,
            UINT NumRects);

    void DiscardView1(
            ID3D11View *pResourceView,
            const D3D11_RECT *pRects,
            UINT NumRects);
}

[
    uuid(b2daad8b-03d4-4dbf-95eb-32ab4b63d0ab),
    object,
    local,
    pointer_default(unique)
]
interface ID3DUserDefinedAnnotation : IUnknown
{
    INT BeginEvent(LPCWSTR Name);
    INT EndEvent();
    void SetMarker(LPCWSTR Name);
    BOOL GetStatus();
}

[
    uuid(1217d7a6-5039-418c-b042-9cbe256afd6e),
    object,
    local,
    pointer_default(unique)
]
interface ID3D11RasterizerState1 : ID3D11RasterizerState
{
    void GetDesc1(D3D11_RASTERIZER_DESC1 *pDesc);
}

[
    uuid(a04bfb29-08ef-43d6-a49c-a9bdbdcbe686),
    object,
    local,
    pointer_default(unique)
]
interface ID3D11Device1 : ID3D11Device
{
    void GetImmediateContext1(
            ID3D11DeviceContext1 **ppImmediateContext);

    HRESULT CreateDeferredContext1(
            UINT ContextFlags,
            ID3D11DeviceContext1 **ppDeferredContext);

    HRESULT CreateBlendState1(
            const D3D11_BLEND_DESC1 *pBlendStateDesc,
            ID3D11BlendState1 **ppBlendState);

    HRESULT CreateRasterizerState1(
            const D3D11_RASTERIZER_DESC1 *pRasterizerDesc,
            ID3D11RasterizerState1 **ppRasterizerState);

    HRESULT CreateDeviceContextState(
            UINT Flags,
            const D3D_FEATURE_LEVEL *pFeatureLevels,
            UINT FeatureLevels,
            UINT SDKVersion,
            REFIID EmulatedInterface,
            D3D_FEATURE_LEVEL *pChosenFeatureLevel,
            ID3DDeviceContextState **ppContextState);

    HRESULT OpenSharedResource1(
            HANDLE hResource,
            REFIID returnedInterface,
            void **ppResource);

     HRESULT OpenSharedResourceByName(
            LPCWSTR lpName,
            DWORD dwDesiredAccess,
            REFIID returnedInterface,
            void **ppResource);
}