alexpete
805 lines
60 KiB
C++
805 lines
60 KiB
C++
/*
|
|
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
|
|
* its licensors.
|
|
*
|
|
* For complete copyright and license terms please see the LICENSE at the root of this
|
|
* distribution (the "License"). All use of this software is governed by the License,
|
|
* or, if provided, by the license below or the license accompanying this file. Do not
|
|
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
*
|
|
*/
|
|
|
|
// Original file Copyright Crytek GMBH or its affiliates, used under license.
|
|
|
|
// Description : Interface wrappers used for full DirectX emulation.
|
|
|
|
#ifndef __DXEmulation__
|
|
#define __DXEmulation__
|
|
|
|
#if DXGL_FULL_EMULATION
|
|
|
|
template <typename Interface>
|
|
struct SingleInheritance
|
|
{
|
|
typedef void TBase;
|
|
};
|
|
#define SINGLE_INHERITANCE(_Derived, _Base) template <> \
|
|
struct SingleInheritance<_Derived> { typedef _Base TBase; };
|
|
|
|
template <typename Interface>
|
|
struct SingleInheritanceInterface
|
|
{
|
|
template <typename Object>
|
|
static bool Query(Object* pThis, REFIID riid, void** ppvObject)
|
|
{
|
|
if (SingleInterface<Interface>::template Query<Object>(pThis, riid, ppvObject))
|
|
{
|
|
return true;
|
|
}
|
|
return SingleInheritanceInterface<typename SingleInheritance<Interface>::TBase>::template Query<Object>(pThis, riid, ppvObject);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct SingleInheritanceInterface<void>
|
|
{
|
|
template <typename Object>
|
|
static bool Query(Object* pThis, REFIID riid, void** ppvObject)
|
|
{
|
|
*ppvObject = NULL;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
SINGLE_INHERITANCE(IUnknown, void)
|
|
SINGLE_INHERITANCE(ID3D10Blob, IUnknown)
|
|
SINGLE_INHERITANCE(ID3D11DeviceChild, IUnknown)
|
|
SINGLE_INHERITANCE(ID3D11DepthStencilState, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11BlendState, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11RasterizerState, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11Resource, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11Buffer, ID3D11Resource)
|
|
SINGLE_INHERITANCE(ID3D11Texture1D, ID3D11Resource)
|
|
SINGLE_INHERITANCE(ID3D11Texture2D, ID3D11Resource)
|
|
SINGLE_INHERITANCE(ID3D11Texture3D, ID3D11Resource)
|
|
SINGLE_INHERITANCE(ID3D11View, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11ShaderResourceView, ID3D11View)
|
|
SINGLE_INHERITANCE(ID3D11RenderTargetView, ID3D11View)
|
|
SINGLE_INHERITANCE(ID3D11DepthStencilView, ID3D11View)
|
|
SINGLE_INHERITANCE(ID3D11UnorderedAccessView, ID3D11View)
|
|
SINGLE_INHERITANCE(ID3D11VertexShader, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11HullShader, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11DomainShader, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11GeometryShader, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11PixelShader, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11ComputeShader, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11InputLayout, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11SamplerState, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11Asynchronous, ID3D11DeviceChild)
|
|
SINGLE_INHERITANCE(ID3D11Query, ID3D11Asynchronous)
|
|
SINGLE_INHERITANCE(ID3D11ShaderReflectionType, void)
|
|
SINGLE_INHERITANCE(ID3D11ShaderReflectionVariable, void)
|
|
SINGLE_INHERITANCE(ID3D11ShaderReflectionConstantBuffer, void)
|
|
SINGLE_INHERITANCE(ID3D11ShaderReflection, IUnknown)
|
|
SINGLE_INHERITANCE(IDXGIObject, IUnknown)
|
|
SINGLE_INHERITANCE(IDXGIDeviceSubObject, IDXGIObject)
|
|
SINGLE_INHERITANCE(IDXGIOutput, IDXGIObject)
|
|
SINGLE_INHERITANCE(IDXGIAdapter, IDXGIObject)
|
|
SINGLE_INHERITANCE(IDXGIAdapter1, IDXGIAdapter)
|
|
SINGLE_INHERITANCE(IDXGIFactory, IDXGIObject)
|
|
SINGLE_INHERITANCE(IDXGIFactory1, IDXGIFactory)
|
|
SINGLE_INHERITANCE(IDXGIDevice, IDXGIObject)
|
|
SINGLE_INHERITANCE(IDXGISwapChain, IDXGIDeviceSubObject)
|
|
SINGLE_INHERITANCE(ID3D11SwitchToRef, IUnknown)
|
|
SINGLE_INHERITANCE(ID3D11Device, IUnknown)
|
|
SINGLE_INHERITANCE(ID3D11DeviceContext, ID3D11DeviceChild)
|
|
|
|
struct SAggregateNode
|
|
{
|
|
SAggregateNode* m_pNext;
|
|
|
|
SAggregateNode()
|
|
: m_pNext(NULL)
|
|
{
|
|
}
|
|
|
|
void Insert(SAggregateNode* pHead)
|
|
{
|
|
m_pNext = pHead->m_pNext;
|
|
pHead->m_pNext = this;
|
|
}
|
|
|
|
virtual bool QueryInterfaceInternal(REFIID riid, void** ppvObject)
|
|
{
|
|
return false;
|
|
};
|
|
};
|
|
|
|
#define DXGL_WRAPPER_ROOT_NO_COM(_Interface) \
|
|
typedef Impl TImpl; \
|
|
TImpl* m_pImpl; \
|
|
void InitializeWrapper(TImpl * pImpl) \
|
|
{ \
|
|
m_pImpl = pImpl; \
|
|
pImpl->m_pVirtual ## _Interface ## Wrapper = this; \
|
|
}
|
|
#define DXGL_WRAPPER_ROOT(_Interface) \
|
|
typedef Impl TImpl; \
|
|
TImpl* m_pImpl; \
|
|
void InitializeWrapper(TImpl * pImpl) \
|
|
{ \
|
|
m_pImpl = pImpl; \
|
|
Insert(&pImpl->GetAggregateHead()); \
|
|
pImpl->m_pVirtual ## _Interface ## Wrapper = this; \
|
|
}
|
|
#define DXGL_WRAPPER_DERIVED(_Interface, _Parent) \
|
|
void InitializeWrapper(typename _Parent<Impl, Base>::TImpl * pImpl) \
|
|
{ \
|
|
_Parent<Impl, Base>::InitializeWrapper(pImpl); \
|
|
pImpl->m_pVirtual ## _Interface ## Wrapper = this; \
|
|
}
|
|
|
|
namespace NDXGLWrappers
|
|
{
|
|
template <typename Impl, typename Base>
|
|
struct SUnknown
|
|
: Base
|
|
, SAggregateNode
|
|
{
|
|
DXGL_WRAPPER_ROOT(Unknown)
|
|
|
|
SUnknown()
|
|
: m_pImpl(NULL) {}
|
|
virtual ~SUnknown(){}
|
|
|
|
ULONG STDMETHODCALLTYPE AddRef(){return m_pImpl->AddRef(); }
|
|
ULONG STDMETHODCALLTYPE Release(){return m_pImpl->Release(); }
|
|
|
|
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject)
|
|
{
|
|
if (SingleInheritanceInterface<Base>::Query(this, riid, ppvObject))
|
|
{
|
|
return S_OK;
|
|
}
|
|
SAggregateNode* pNode(m_pImpl->GetAggregateHead().m_pNext);
|
|
while (pNode != NULL)
|
|
{
|
|
if (pNode->QueryInterfaceInternal(riid, ppvObject))
|
|
{
|
|
return S_OK;
|
|
}
|
|
pNode = pNode->m_pNext;
|
|
}
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
bool QueryInterfaceInternal(REFIID riid, void** ppvObject)
|
|
{
|
|
return SingleInheritanceInterface<Base>::Query(this, riid, ppvObject);
|
|
}
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D10Blob
|
|
: SUnknown<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D10Blob, SUnknown)
|
|
SD3D10Blob(){}
|
|
LPVOID STDMETHODCALLTYPE GetBufferPointer(){return this->m_pImpl->GetBufferPointer(); }
|
|
SIZE_T STDMETHODCALLTYPE GetBufferSize(){return this->m_pImpl->GetBufferSize(); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11DeviceChild
|
|
: SUnknown<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11DeviceChild, SUnknown)
|
|
SD3D11DeviceChild(){}
|
|
void STDMETHODCALLTYPE GetDevice(ID3D11Device** ppDevice){this->m_pImpl->GetDevice(ppDevice); }
|
|
HRESULT STDMETHODCALLTYPE GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData){return this->m_pImpl->GetPrivateData(guid, pDataSize, pData); }
|
|
HRESULT STDMETHODCALLTYPE SetPrivateData(REFGUID guid, UINT DataSize, const void* pData){return this->m_pImpl->SetPrivateData(guid, DataSize, pData); }
|
|
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(REFGUID guid, const IUnknown* pData){return this->m_pImpl->SetPrivateDataInterface(guid, pData); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11DepthStencilState
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11DepthStencilState, SD3D11DeviceChild)
|
|
SD3D11DepthStencilState(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_DEPTH_STENCIL_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11BlendState
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11BlendState, SD3D11DeviceChild)
|
|
SD3D11BlendState(){}
|
|
virtual void STDMETHODCALLTYPE GetDesc(D3D11_BLEND_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11RasterizerState
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11RasterizerState, SD3D11DeviceChild)
|
|
SD3D11RasterizerState(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_RASTERIZER_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Resource
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Resource, SD3D11DeviceChild)
|
|
SD3D11Resource(){}
|
|
void STDMETHODCALLTYPE GetType(D3D11_RESOURCE_DIMENSION* pResourceDimension){this->m_pImpl->GetType(pResourceDimension); }
|
|
void STDMETHODCALLTYPE SetEvictionPriority(UINT EvictionPriority){this->m_pImpl->SetEvictionPriority(EvictionPriority); }
|
|
UINT STDMETHODCALLTYPE GetEvictionPriority(){return this->m_pImpl->GetEvictionPriority(); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Buffer
|
|
: SD3D11Resource<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Buffer, SD3D11Resource)
|
|
SD3D11Buffer(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_BUFFER_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Texture1D
|
|
: SD3D11Resource<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Texture1D, SD3D11Resource)
|
|
SD3D11Texture1D(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_TEXTURE1D_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Texture2D
|
|
: SD3D11Resource<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Texture2D, SD3D11Resource)
|
|
SD3D11Texture2D(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_TEXTURE2D_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Texture3D
|
|
: SD3D11Resource<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Texture3D, SD3D11Resource)
|
|
SD3D11Texture3D(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_TEXTURE3D_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11View
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11View, SD3D11DeviceChild)
|
|
SD3D11View(){}
|
|
void STDMETHODCALLTYPE GetResource(ID3D11Resource** ppResource){this->m_pImpl->GetResource(ppResource); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11ShaderResourceView
|
|
: SD3D11View<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11ShaderResourceView, SD3D11View)
|
|
SD3D11ShaderResourceView(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11RenderTargetView
|
|
: SD3D11View<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11RenderTargetView, SD3D11View)
|
|
SD3D11RenderTargetView(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_RENDER_TARGET_VIEW_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11DepthStencilView
|
|
: SD3D11View<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11DepthStencilView, SD3D11View)
|
|
SD3D11DepthStencilView(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11UnorderedAccessView
|
|
: SD3D11View<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11UnorderedAccessView, SD3D11View)
|
|
SD3D11UnorderedAccessView(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11VertexShader
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11VertexShader, SD3D11DeviceChild) SD3D11VertexShader()
|
|
{
|
|
}
|
|
};
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11HullShader
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11HullShader, SD3D11DeviceChild) SD3D11HullShader()
|
|
{
|
|
}
|
|
};
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11DomainShader
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11DomainShader, SD3D11DeviceChild) SD3D11DomainShader()
|
|
{
|
|
}
|
|
};
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11GeometryShader
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11GeometryShader, SD3D11DeviceChild) SD3D11GeometryShader()
|
|
{
|
|
}
|
|
};
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11PixelShader
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11PixelShader, SD3D11DeviceChild) SD3D11PixelShader()
|
|
{
|
|
}
|
|
};
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11ComputeShader
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11ComputeShader, SD3D11DeviceChild) SD3D11ComputeShader()
|
|
{
|
|
}
|
|
};
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11InputLayout
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11InputLayout, SD3D11DeviceChild) SD3D11InputLayout()
|
|
{
|
|
}
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11SamplerState
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11SamplerState, SD3D11DeviceChild)
|
|
SD3D11SamplerState(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_SAMPLER_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Asynchronous
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Asynchronous, SD3D11DeviceChild)
|
|
SD3D11Asynchronous(){}
|
|
UINT STDMETHODCALLTYPE GetDataSize(){return this->m_pImpl->GetDataSize(); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Query
|
|
: SD3D11Asynchronous<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Query, SD3D11Asynchronous)
|
|
SD3D11Query(){}
|
|
void STDMETHODCALLTYPE GetDesc(D3D11_QUERY_DESC* pDesc){this->m_pImpl->GetDesc(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11ShaderReflectionType
|
|
: Base
|
|
{
|
|
DXGL_WRAPPER_ROOT_NO_COM(D3D11ShaderReflectionType)
|
|
SD3D11ShaderReflectionType()
|
|
: m_pImpl(NULL){}
|
|
~SD3D11ShaderReflectionType(){}
|
|
HRESULT STDMETHODCALLTYPE GetDesc(D3D11_SHADER_TYPE_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
ID3D11ShaderReflectionType* STDMETHODCALLTYPE GetMemberTypeByIndex(UINT Index){return this->m_pImpl->GetMemberTypeByIndex(Index); }
|
|
ID3D11ShaderReflectionType* STDMETHODCALLTYPE GetMemberTypeByName(LPCSTR Name){return this->m_pImpl->GetMemberTypeByName(Name); }
|
|
LPCSTR STDMETHODCALLTYPE GetMemberTypeName(UINT Index){return this->m_pImpl->GetMemberTypeName(Index); }
|
|
HRESULT STDMETHODCALLTYPE IsEqual(ID3D11ShaderReflectionType* pType){return this->m_pImpl->IsEqual(pType); }
|
|
ID3D11ShaderReflectionType* STDMETHODCALLTYPE GetSubType(){return this->m_pImpl->GetSubType(); }
|
|
ID3D11ShaderReflectionType* STDMETHODCALLTYPE GetBaseClass(){return this->m_pImpl->GetBaseClass(); }
|
|
UINT STDMETHODCALLTYPE GetNumInterfaces(){return this->m_pImpl->GetNumInterfaces(); }
|
|
ID3D11ShaderReflectionType* STDMETHODCALLTYPE GetInterfaceByIndex(UINT uIndex){return this->m_pImpl->GetInterfaceByIndex(uIndex); }
|
|
HRESULT STDMETHODCALLTYPE IsOfType(ID3D11ShaderReflectionType* pType){return this->m_pImpl->IsOfType(pType); }
|
|
HRESULT STDMETHODCALLTYPE ImplementsInterface(ID3D11ShaderReflectionType* pBase){return this->m_pImpl->ImplementsInterface(pBase); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11ShaderReflectionVariable
|
|
: Base
|
|
{
|
|
DXGL_WRAPPER_ROOT_NO_COM(D3D11ShaderReflectionVariable)
|
|
SD3D11ShaderReflectionVariable()
|
|
: m_pImpl(NULL){}
|
|
~SD3D11ShaderReflectionVariable(){}
|
|
HRESULT STDMETHODCALLTYPE GetDesc(D3D11_SHADER_VARIABLE_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
ID3D11ShaderReflectionType* STDMETHODCALLTYPE GetType(){return this->m_pImpl->GetType(); }
|
|
ID3D11ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetBuffer(){return this->m_pImpl->GetBuffer(); }
|
|
UINT STDMETHODCALLTYPE GetInterfaceSlot(UINT uArrayIndex){return this->m_pImpl->GetInterfaceSlot(uArrayIndex); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11ShaderReflectionConstantBuffer
|
|
: Base
|
|
{
|
|
DXGL_WRAPPER_ROOT_NO_COM(D3D11ShaderReflectionConstantBuffer)
|
|
SD3D11ShaderReflectionConstantBuffer()
|
|
: m_pImpl(NULL){}
|
|
~SD3D11ShaderReflectionConstantBuffer(){}
|
|
HRESULT STDMETHODCALLTYPE GetDesc(D3D11_SHADER_BUFFER_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
ID3D11ShaderReflectionVariable* STDMETHODCALLTYPE GetVariableByIndex(UINT Index){return this->m_pImpl->GetVariableByIndex(Index); }
|
|
ID3D11ShaderReflectionVariable* STDMETHODCALLTYPE GetVariableByName(LPCSTR Name){return this->m_pImpl->GetVariableByName(Name); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11ShaderReflection
|
|
: SUnknown<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11ShaderReflection, SUnknown)
|
|
SD3D11ShaderReflection(){}
|
|
HRESULT STDMETHODCALLTYPE GetDesc(D3D11_SHADER_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
ID3D11ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetConstantBufferByIndex(UINT Index){return this->m_pImpl->GetConstantBufferByIndex(Index); }
|
|
ID3D11ShaderReflectionConstantBuffer* STDMETHODCALLTYPE GetConstantBufferByName(LPCSTR Name){return this->m_pImpl->GetConstantBufferByName(Name); }
|
|
HRESULT STDMETHODCALLTYPE GetResourceBindingDesc(UINT ResourceIndex, D3D11_SHADER_INPUT_BIND_DESC* pDesc){return this->m_pImpl->GetResourceBindingDesc(ResourceIndex, pDesc); }
|
|
HRESULT STDMETHODCALLTYPE GetInputParameterDesc(UINT ParameterIndex, D3D11_SIGNATURE_PARAMETER_DESC* pDesc){return this->m_pImpl->GetInputParameterDesc(ParameterIndex, pDesc); }
|
|
HRESULT STDMETHODCALLTYPE GetOutputParameterDesc(UINT ParameterIndex, D3D11_SIGNATURE_PARAMETER_DESC* pDesc){return this->m_pImpl->GetOutputParameterDesc(ParameterIndex, pDesc); }
|
|
HRESULT STDMETHODCALLTYPE GetPatchConstantParameterDesc(UINT ParameterIndex, D3D11_SIGNATURE_PARAMETER_DESC* pDesc){return this->m_pImpl->GetPatchConstantParameterDesc(ParameterIndex, pDesc); }
|
|
ID3D11ShaderReflectionVariable* STDMETHODCALLTYPE GetVariableByName(LPCSTR Name){return this->m_pImpl->GetVariableByName(Name); }
|
|
HRESULT STDMETHODCALLTYPE GetResourceBindingDescByName(LPCSTR Name, D3D11_SHADER_INPUT_BIND_DESC* pDesc){return this->m_pImpl->GetResourceBindingDescByName(Name, pDesc); }
|
|
UINT STDMETHODCALLTYPE GetMovInstructionCount(){return this->m_pImpl->GetMovInstructionCount(); }
|
|
UINT STDMETHODCALLTYPE GetMovcInstructionCount(){return this->m_pImpl->GetMovcInstructionCount(); }
|
|
UINT STDMETHODCALLTYPE GetConversionInstructionCount(){return this->m_pImpl->GetConversionInstructionCount(); }
|
|
UINT STDMETHODCALLTYPE GetBitwiseInstructionCount(){return this->m_pImpl->GetBitwiseInstructionCount(); }
|
|
D3D_PRIMITIVE STDMETHODCALLTYPE GetGSInputPrimitive(){return this->m_pImpl->GetGSInputPrimitive(); }
|
|
BOOL STDMETHODCALLTYPE IsSampleFrequencyShader(){return this->m_pImpl->IsSampleFrequencyShader(); }
|
|
UINT STDMETHODCALLTYPE GetNumInterfaceSlots(){return this->m_pImpl->GetNumInterfaceSlots(); }
|
|
HRESULT STDMETHODCALLTYPE GetMinFeatureLevel(D3D_FEATURE_LEVEL* pLevel){return this->m_pImpl->GetMinFeatureLevel(pLevel); }
|
|
};
|
|
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIObject
|
|
: SUnknown<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIObject, SUnknown)
|
|
SDXGIObject(){}
|
|
HRESULT STDMETHODCALLTYPE SetPrivateData(REFGUID Name, UINT DataSize, const void* pData){return this->m_pImpl->SetPrivateData(Name, DataSize, pData); }
|
|
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(REFGUID Name, const IUnknown* pUnknown){return this->m_pImpl->SetPrivateDataInterface(Name, pUnknown); }
|
|
HRESULT STDMETHODCALLTYPE GetPrivateData(REFGUID Name, UINT* pDataSize, void* pData){return this->m_pImpl->GetPrivateData(Name, pDataSize, pData); }
|
|
HRESULT STDMETHODCALLTYPE GetParent(REFIID riid, void** ppParent){return this->m_pImpl->GetParent(riid, ppParent); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIDeviceSubObject
|
|
: SDXGIObject<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIDeviceSubObject, SDXGIObject)
|
|
SDXGIDeviceSubObject(){}
|
|
HRESULT STDMETHODCALLTYPE GetDevice(REFIID riid, void** ppDevice){return this->m_pImpl->GetDevice(riid, ppDevice); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIOutput
|
|
: SDXGIObject<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIOutput, SDXGIObject)
|
|
SDXGIOutput(){}
|
|
HRESULT STDMETHODCALLTYPE GetDesc(DXGI_OUTPUT_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
HRESULT STDMETHODCALLTYPE GetDisplayModeList(DXGI_FORMAT EnumFormat, UINT Flags, UINT* pNumModes, DXGI_MODE_DESC* pDesc){return this->m_pImpl->GetDisplayModeList(EnumFormat, Flags, pNumModes, pDesc); }
|
|
HRESULT STDMETHODCALLTYPE FindClosestMatchingMode(const DXGI_MODE_DESC* pModeToMatch, DXGI_MODE_DESC* pClosestMatch, IUnknown* pConcernedDevice){return this->m_pImpl->FindClosestMatchingMode(pModeToMatch, pClosestMatch, pConcernedDevice); }
|
|
HRESULT STDMETHODCALLTYPE WaitForVBlank(){return this->m_pImpl->WaitForVBlank(); }
|
|
HRESULT STDMETHODCALLTYPE TakeOwnership(IUnknown* pDevice, BOOL Exclusive){return this->m_pImpl->TakeOwnership(pDevice, Exclusive); }
|
|
void STDMETHODCALLTYPE ReleaseOwnership(){this->m_pImpl->ReleaseOwnership(); }
|
|
HRESULT STDMETHODCALLTYPE GetGammaControlCapabilities(DXGI_GAMMA_CONTROL_CAPABILITIES* pGammaCaps){return this->m_pImpl->GetGammaControlCapabilities(pGammaCaps); }
|
|
HRESULT STDMETHODCALLTYPE SetGammaControl(const DXGI_GAMMA_CONTROL* pArray){return this->m_pImpl->SetGammaControl(pArray); }
|
|
HRESULT STDMETHODCALLTYPE GetGammaControl(DXGI_GAMMA_CONTROL* pArray){return this->m_pImpl->GetGammaControl(pArray); }
|
|
HRESULT STDMETHODCALLTYPE SetDisplaySurface(IDXGISurface* pScanoutSurface){return this->m_pImpl->SetDisplaySurface(pScanoutSurface); }
|
|
HRESULT STDMETHODCALLTYPE GetDisplaySurfaceData(IDXGISurface* pDestination){return this->m_pImpl->GetDisplaySurfaceData(pDestination); }
|
|
HRESULT STDMETHODCALLTYPE GetFrameStatistics(DXGI_FRAME_STATISTICS* pStats){return this->m_pImpl->GetFrameStatistics(pStats); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIAdapter
|
|
: SDXGIObject<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIAdapter, SDXGIObject)
|
|
SDXGIAdapter(){}
|
|
HRESULT STDMETHODCALLTYPE EnumOutputs(UINT Output, IDXGIOutput** ppOutput){return this->m_pImpl->EnumOutputs(Output, ppOutput); }
|
|
HRESULT STDMETHODCALLTYPE GetDesc(DXGI_ADAPTER_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
HRESULT STDMETHODCALLTYPE CheckInterfaceSupport(REFGUID InterfaceName, LARGE_INTEGER* pUMDVersion){return this->m_pImpl->CheckInterfaceSupport(InterfaceName, pUMDVersion); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIAdapter1
|
|
: SDXGIAdapter<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIAdapter1, SDXGIAdapter)
|
|
SDXGIAdapter1(){}
|
|
HRESULT STDMETHODCALLTYPE GetDesc1(DXGI_ADAPTER_DESC1* pDesc){return this->m_pImpl->GetDesc1(pDesc); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIFactory
|
|
: SDXGIObject<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIFactory, SDXGIObject)
|
|
SDXGIFactory(){}
|
|
HRESULT STDMETHODCALLTYPE EnumAdapters(UINT Adapter, IDXGIAdapter** ppAdapter){return this->m_pImpl->EnumAdapters(Adapter, ppAdapter); }
|
|
HRESULT STDMETHODCALLTYPE MakeWindowAssociation(HWND WindowHandle, UINT Flags){return this->m_pImpl->MakeWindowAssociation(WindowHandle, Flags); }
|
|
HRESULT STDMETHODCALLTYPE GetWindowAssociation(HWND* pWindowHandle){return this->m_pImpl->GetWindowAssociation(pWindowHandle); }
|
|
HRESULT STDMETHODCALLTYPE CreateSwapChain(IUnknown* pDevice, DXGI_SWAP_CHAIN_DESC* pDesc, IDXGISwapChain** ppSwapChain){return this->m_pImpl->CreateSwapChain(pDevice, pDesc, ppSwapChain); }
|
|
HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter(HMODULE Module, IDXGIAdapter** ppAdapter){return this->m_pImpl->CreateSoftwareAdapter(Module, ppAdapter); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIFactory1
|
|
: SDXGIFactory<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIFactory1, SDXGIFactory)
|
|
SDXGIFactory1(){}
|
|
HRESULT STDMETHODCALLTYPE EnumAdapters1(UINT Adapter, IDXGIAdapter1** ppAdapter){return this->m_pImpl->EnumAdapters1(Adapter, ppAdapter); }
|
|
BOOL STDMETHODCALLTYPE IsCurrent(void){return this->m_pImpl->IsCurrent(); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGIDevice
|
|
: SDXGIObject<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGIDevice, SDXGIObject)
|
|
SDXGIDevice(){}
|
|
HRESULT STDMETHODCALLTYPE GetAdapter(IDXGIAdapter** pAdapter){return this->m_pImpl->GetAdapter(pAdapter); }
|
|
HRESULT STDMETHODCALLTYPE CreateSurface(const DXGI_SURFACE_DESC* pDesc, UINT NumSurfaces, DXGI_USAGE Usage, const DXGI_SHARED_RESOURCE* pSharedResource, IDXGISurface** ppSurface){return this->m_pImpl->CreateSurface(pDesc, NumSurfaces, Usage, pSharedResource, ppSurface); }
|
|
HRESULT STDMETHODCALLTYPE QueryResourceResidency(IUnknown* const* ppResources, DXGI_RESIDENCY* pResidencyStatus, UINT NumResources){return this->m_pImpl->QueryResourceResidency(ppResources, pResidencyStatus, NumResources); }
|
|
HRESULT STDMETHODCALLTYPE SetGPUThreadPriority(INT Priority){return this->m_pImpl->SetGPUThreadPriority(Priority); }
|
|
HRESULT STDMETHODCALLTYPE GetGPUThreadPriority(INT* pPriority){return this->m_pImpl->GetGPUThreadPriority(pPriority); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SDXGISwapChain
|
|
: SDXGIDeviceSubObject<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(DXGISwapChain, SDXGIDeviceSubObject)
|
|
SDXGISwapChain(){}
|
|
HRESULT STDMETHODCALLTYPE Present(UINT SyncInterval, UINT Flags){return this->m_pImpl->Present(SyncInterval, Flags); }
|
|
HRESULT STDMETHODCALLTYPE GetBuffer(UINT Buffer, REFIID riid, void** ppSurface){return this->m_pImpl->GetBuffer(Buffer, riid, ppSurface); }
|
|
HRESULT STDMETHODCALLTYPE SetFullscreenState(BOOL Fullscreen, IDXGIOutput* pTarget){return this->m_pImpl->SetFullscreenState(Fullscreen, pTarget); }
|
|
HRESULT STDMETHODCALLTYPE GetFullscreenState(BOOL* pFullscreen, IDXGIOutput** ppTarget){return this->m_pImpl->GetFullscreenState(pFullscreen, ppTarget); }
|
|
HRESULT STDMETHODCALLTYPE GetDesc(DXGI_SWAP_CHAIN_DESC* pDesc){return this->m_pImpl->GetDesc(pDesc); }
|
|
HRESULT STDMETHODCALLTYPE ResizeBuffers(UINT BufferCount, UINT Width, UINT Height, DXGI_FORMAT NewFormat, UINT SwapChainFlags){return this->m_pImpl->ResizeBuffers(BufferCount, Width, Height, NewFormat, SwapChainFlags); }
|
|
HRESULT STDMETHODCALLTYPE ResizeTarget(const DXGI_MODE_DESC* pNewTargetParameters){return this->m_pImpl->ResizeTarget(pNewTargetParameters); }
|
|
HRESULT STDMETHODCALLTYPE GetContainingOutput(IDXGIOutput** ppOutput){return this->m_pImpl->GetContainingOutput(ppOutput); }
|
|
HRESULT STDMETHODCALLTYPE GetFrameStatistics(DXGI_FRAME_STATISTICS* pStats){return this->m_pImpl->GetFrameStatistics(pStats); }
|
|
HRESULT STDMETHODCALLTYPE GetLastPresentCount(UINT* pLastPresentCount){return this->m_pImpl->GetLastPresentCount(pLastPresentCount); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11SwitchToRef
|
|
: public SUnknown<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11SwitchToRef, SUnknown)
|
|
SD3D11SwitchToRef(){}
|
|
BOOL STDMETHODCALLTYPE SetUseRef(BOOL UseRef){return this->m_pImpl->SetUseRef(UseRef); }
|
|
BOOL STDMETHODCALLTYPE GetUseRef(){return this->m_pImpl->GetUseRef(); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11Device
|
|
: public SUnknown<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11Device, SUnknown)
|
|
HRESULT STDMETHODCALLTYPE CreateBuffer(const D3D11_BUFFER_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Buffer** ppBuffer){return this->m_pImpl->CreateBuffer(pDesc, pInitialData, ppBuffer); }
|
|
HRESULT STDMETHODCALLTYPE CreateTexture1D(const D3D11_TEXTURE1D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture1D** ppTexture1D){return this->m_pImpl->CreateTexture1D(pDesc, pInitialData, ppTexture1D); }
|
|
HRESULT STDMETHODCALLTYPE CreateTexture2D(const D3D11_TEXTURE2D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture2D** ppTexture2D){return this->m_pImpl->CreateTexture2D(pDesc, pInitialData, ppTexture2D); }
|
|
HRESULT STDMETHODCALLTYPE CreateTexture3D(const D3D11_TEXTURE3D_DESC* pDesc, const D3D11_SUBRESOURCE_DATA* pInitialData, ID3D11Texture3D** ppTexture3D){return this->m_pImpl->CreateTexture3D(pDesc, pInitialData, ppTexture3D); }
|
|
HRESULT STDMETHODCALLTYPE CreateShaderResourceView(ID3D11Resource* pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc, ID3D11ShaderResourceView** ppSRView){return this->m_pImpl->CreateShaderResourceView(pResource, pDesc, ppSRView); }
|
|
HRESULT STDMETHODCALLTYPE CreateUnorderedAccessView(ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc, ID3D11UnorderedAccessView** ppUAView){return this->m_pImpl->CreateUnorderedAccessView(pResource, pDesc, ppUAView); }
|
|
HRESULT STDMETHODCALLTYPE CreateRenderTargetView(ID3D11Resource* pResource, const D3D11_RENDER_TARGET_VIEW_DESC* pDesc, ID3D11RenderTargetView** ppRTView){return this->m_pImpl->CreateRenderTargetView(pResource, pDesc, ppRTView); }
|
|
HRESULT STDMETHODCALLTYPE CreateDepthStencilView(ID3D11Resource* pResource, const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc, ID3D11DepthStencilView** ppDepthStencilView){return this->m_pImpl->CreateDepthStencilView(pResource, pDesc, ppDepthStencilView); }
|
|
HRESULT STDMETHODCALLTYPE CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs, UINT NumElements, const void* pShaderBytecodeWithInputSignature, SIZE_T BytecodeLength, ID3D11InputLayout** ppInputLayout){return this->m_pImpl->CreateInputLayout(pInputElementDescs, NumElements, pShaderBytecodeWithInputSignature, BytecodeLength, ppInputLayout); }
|
|
HRESULT STDMETHODCALLTYPE CreateVertexShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11VertexShader** ppVertexShader){return this->m_pImpl->CreateVertexShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader); }
|
|
HRESULT STDMETHODCALLTYPE CreateGeometryShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader){return this->m_pImpl->CreateGeometryShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppGeometryShader); }
|
|
HRESULT STDMETHODCALLTYPE CreateGeometryShaderWithStreamOutput(const void* pShaderBytecode, SIZE_T BytecodeLength, const D3D11_SO_DECLARATION_ENTRY* pSODeclaration, UINT NumEntries, const UINT* pBufferStrides, UINT NumStrides, UINT RasterizedStream, ID3D11ClassLinkage* pClassLinkage, ID3D11GeometryShader** ppGeometryShader){return this->m_pImpl->CreateGeometryShaderWithStreamOutput(pShaderBytecode, BytecodeLength, pSODeclaration, NumEntries, pBufferStrides, NumStrides, RasterizedStream, pClassLinkage, ppGeometryShader); }
|
|
HRESULT STDMETHODCALLTYPE CreatePixelShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11PixelShader** ppPixelShader){return this->m_pImpl->CreatePixelShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader); }
|
|
HRESULT STDMETHODCALLTYPE CreateHullShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11HullShader** ppHullShader){return this->m_pImpl->CreateHullShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppHullShader); }
|
|
HRESULT STDMETHODCALLTYPE CreateDomainShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11DomainShader** ppDomainShader){return this->m_pImpl->CreateDomainShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppDomainShader); }
|
|
HRESULT STDMETHODCALLTYPE CreateComputeShader(const void* pShaderBytecode, SIZE_T BytecodeLength, ID3D11ClassLinkage* pClassLinkage, ID3D11ComputeShader** ppComputeShader){return this->m_pImpl->CreateComputeShader(pShaderBytecode, BytecodeLength, pClassLinkage, ppComputeShader); }
|
|
HRESULT STDMETHODCALLTYPE CreateClassLinkage(ID3D11ClassLinkage** ppLinkage){return this->m_pImpl->CreateClassLinkage(ppLinkage); }
|
|
HRESULT STDMETHODCALLTYPE CreateBlendState(const D3D11_BLEND_DESC* pBlendStateDesc, ID3D11BlendState** ppBlendState){return this->m_pImpl->CreateBlendState(pBlendStateDesc, ppBlendState); }
|
|
HRESULT STDMETHODCALLTYPE CreateDepthStencilState(const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc, ID3D11DepthStencilState** ppDepthStencilState){return this->m_pImpl->CreateDepthStencilState(pDepthStencilDesc, ppDepthStencilState); }
|
|
HRESULT STDMETHODCALLTYPE CreateRasterizerState(const D3D11_RASTERIZER_DESC* pRasterizerDesc, ID3D11RasterizerState** ppRasterizerState){return this->m_pImpl->CreateRasterizerState(pRasterizerDesc, ppRasterizerState); }
|
|
HRESULT STDMETHODCALLTYPE CreateSamplerState(const D3D11_SAMPLER_DESC* pSamplerDesc, ID3D11SamplerState** ppSamplerState){return this->m_pImpl->CreateSamplerState(pSamplerDesc, ppSamplerState); }
|
|
HRESULT STDMETHODCALLTYPE CreateQuery(const D3D11_QUERY_DESC* pQueryDesc, ID3D11Query** ppQuery){return this->m_pImpl->CreateQuery(pQueryDesc, ppQuery); }
|
|
HRESULT STDMETHODCALLTYPE CreatePredicate(const D3D11_QUERY_DESC* pPredicateDesc, ID3D11Predicate** ppPredicate){return this->m_pImpl->CreatePredicate(pPredicateDesc, ppPredicate); }
|
|
HRESULT STDMETHODCALLTYPE CreateCounter(const D3D11_COUNTER_DESC* pCounterDesc, ID3D11Counter** ppCounter){return this->m_pImpl->CreateCounter(pCounterDesc, ppCounter); }
|
|
HRESULT STDMETHODCALLTYPE CreateDeferredContext(UINT ContextFlags, ID3D11DeviceContext** ppDeferredContext){return this->m_pImpl->CreateDeferredContext(ContextFlags, ppDeferredContext); }
|
|
HRESULT STDMETHODCALLTYPE OpenSharedResource(HANDLE hResource, REFIID ReturnedInterface, void** ppResource){return this->m_pImpl->OpenSharedResource(hResource, ReturnedInterface, ppResource); }
|
|
HRESULT STDMETHODCALLTYPE CheckFormatSupport(DXGI_FORMAT Format, UINT* pFormatSupport){return this->m_pImpl->CheckFormatSupport(Format, pFormatSupport); }
|
|
HRESULT STDMETHODCALLTYPE CheckMultisampleQualityLevels(DXGI_FORMAT Format, UINT SampleCount, UINT* pNumQualityLevels){return this->m_pImpl->CheckMultisampleQualityLevels(Format, SampleCount, pNumQualityLevels); }
|
|
void STDMETHODCALLTYPE CheckCounterInfo(D3D11_COUNTER_INFO* pCounterInfo){this->m_pImpl->CheckCounterInfo(pCounterInfo); }
|
|
HRESULT STDMETHODCALLTYPE CheckCounter(const D3D11_COUNTER_DESC* pDesc, D3D11_COUNTER_TYPE* pType, UINT* pActiveCounters, LPSTR szName, UINT* pNameLength, LPSTR szUnits, UINT* pUnitsLength, LPSTR szDescription, UINT* pDescriptionLength){return this->m_pImpl->CheckCounter(pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength); }
|
|
HRESULT STDMETHODCALLTYPE CheckFeatureSupport(D3D11_FEATURE Feature, void* pFeatureSupportData, UINT FeatureSupportDataSize) {return this->m_pImpl->CheckFeatureSupport(Feature, pFeatureSupportData, FeatureSupportDataSize); }
|
|
HRESULT STDMETHODCALLTYPE GetPrivateData(REFGUID guid, UINT* pDataSize, void* pData){return this->m_pImpl->GetPrivateData(guid, pDataSize, pData); }
|
|
HRESULT STDMETHODCALLTYPE SetPrivateData(REFGUID guid, UINT DataSize, const void* pData){return this->m_pImpl->SetPrivateData(guid, DataSize, pData); }
|
|
HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(REFGUID guid, const IUnknown* pData){return this->m_pImpl->SetPrivateDataInterface(guid, pData); }
|
|
D3D_FEATURE_LEVEL STDMETHODCALLTYPE GetFeatureLevel(void){return this->m_pImpl->GetFeatureLevel(); }
|
|
UINT STDMETHODCALLTYPE GetCreationFlags(void){return this->m_pImpl->GetCreationFlags(); }
|
|
HRESULT STDMETHODCALLTYPE GetDeviceRemovedReason(void){return this->m_pImpl->GetDeviceRemovedReason(); }
|
|
void STDMETHODCALLTYPE GetImmediateContext(ID3D11DeviceContext** ppImmediateContext){this->m_pImpl->GetImmediateContext(ppImmediateContext); }
|
|
HRESULT STDMETHODCALLTYPE SetExceptionMode(UINT RaiseFlags){return this->m_pImpl->SetExceptionMode(RaiseFlags); }
|
|
UINT STDMETHODCALLTYPE GetExceptionMode(void){return this->m_pImpl->GetExceptionMode(); }
|
|
};
|
|
|
|
template <typename Impl, typename Base>
|
|
struct SD3D11DeviceContext
|
|
: SD3D11DeviceChild<Impl, Base>
|
|
{
|
|
DXGL_WRAPPER_DERIVED(D3D11DeviceContext, SD3D11DeviceChild)
|
|
void STDMETHODCALLTYPE VSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers){this->m_pImpl->VSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE PSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews){this->m_pImpl->PSSetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE PSSetShader(ID3D11PixelShader* pPixelShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances){this->m_pImpl->PSSetShader(pPixelShader, ppClassInstances, NumClassInstances); }
|
|
void STDMETHODCALLTYPE PSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers){this->m_pImpl->PSSetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE VSSetShader(ID3D11VertexShader* pVertexShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances){this->m_pImpl->VSSetShader(pVertexShader, ppClassInstances, NumClassInstances); }
|
|
void STDMETHODCALLTYPE DrawIndexed(UINT IndexCount, UINT StartIndexLocation, INT BaseVertexLocation){this->m_pImpl->DrawIndexed(IndexCount, StartIndexLocation, BaseVertexLocation); }
|
|
void STDMETHODCALLTYPE Draw(UINT VertexCount, UINT StartVertexLocation){this->m_pImpl->Draw(VertexCount, StartVertexLocation); }
|
|
HRESULT STDMETHODCALLTYPE Map(ID3D11Resource* pResource, UINT Subresource, D3D11_MAP MapType, UINT MapFlags, D3D11_MAPPED_SUBRESOURCE* pMappedResource){return this->m_pImpl->Map(pResource, Subresource, MapType, MapFlags, pMappedResource); }
|
|
void STDMETHODCALLTYPE Unmap(ID3D11Resource* pResource, UINT Subresource){this->m_pImpl->Unmap(pResource, Subresource); }
|
|
void STDMETHODCALLTYPE PSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers){this->m_pImpl->PSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE IASetInputLayout(ID3D11InputLayout* pInputLayout){this->m_pImpl->IASetInputLayout(pInputLayout); }
|
|
void STDMETHODCALLTYPE IASetVertexBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppVertexBuffers, const UINT* pStrides, const UINT* pOffsets){this->m_pImpl->IASetVertexBuffers(StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); }
|
|
void STDMETHODCALLTYPE IASetIndexBuffer(ID3D11Buffer* pIndexBuffer, DXGI_FORMAT Format, UINT Offset){this->m_pImpl->IASetIndexBuffer(pIndexBuffer, Format, Offset); }
|
|
void STDMETHODCALLTYPE DrawIndexedInstanced(UINT IndexCountPerInstance, UINT InstanceCount, UINT StartIndexLocation, INT BaseVertexLocation, UINT StartInstanceLocation){this->m_pImpl->DrawIndexedInstanced(IndexCountPerInstance, InstanceCount, StartIndexLocation, BaseVertexLocation, StartInstanceLocation); }
|
|
void STDMETHODCALLTYPE DrawInstanced(UINT VertexCountPerInstance, UINT InstanceCount, UINT StartVertexLocation, UINT StartInstanceLocation){this->m_pImpl->DrawInstanced(VertexCountPerInstance, InstanceCount, StartVertexLocation, StartInstanceLocation); }
|
|
void STDMETHODCALLTYPE GSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers){this->m_pImpl->GSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE GSSetShader(ID3D11GeometryShader* pShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances){this->m_pImpl->GSSetShader(pShader, ppClassInstances, NumClassInstances); }
|
|
void STDMETHODCALLTYPE IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY Topology){this->m_pImpl->IASetPrimitiveTopology(Topology); }
|
|
void STDMETHODCALLTYPE VSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews){this->m_pImpl->VSSetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE VSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers){this->m_pImpl->VSSetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE Begin(ID3D11Asynchronous* pAsync){this->m_pImpl->Begin(pAsync); }
|
|
void STDMETHODCALLTYPE End(ID3D11Asynchronous* pAsync){this->m_pImpl->End(pAsync); }
|
|
HRESULT STDMETHODCALLTYPE GetData(ID3D11Asynchronous* pAsync, void* pData, UINT DataSize, UINT GetDataFlags){return this->m_pImpl->GetData(pAsync, pData, DataSize, GetDataFlags); }
|
|
void STDMETHODCALLTYPE SetPredication(ID3D11Predicate* pPredicate, BOOL PredicateValue){this->m_pImpl->SetPredication(pPredicate, PredicateValue); }
|
|
void STDMETHODCALLTYPE GSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews){this->m_pImpl->GSSetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE GSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers){this->m_pImpl->GSSetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE OMSetRenderTargets(UINT NumViews, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView){this->m_pImpl->OMSetRenderTargets(NumViews, ppRenderTargetViews, pDepthStencilView); }
|
|
void STDMETHODCALLTYPE OMSetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, ID3D11RenderTargetView* const* ppRenderTargetViews, ID3D11DepthStencilView* pDepthStencilView, UINT UAVStartSlot, UINT NumUAVs, ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts){this->m_pImpl->OMSetRenderTargetsAndUnorderedAccessViews(NumRTVs, ppRenderTargetViews, pDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); }
|
|
void STDMETHODCALLTYPE OMSetBlendState(ID3D11BlendState* pBlendState, const FLOAT BlendFactor[ 4 ], UINT SampleMask){this->m_pImpl->OMSetBlendState(pBlendState, BlendFactor, SampleMask); }
|
|
void STDMETHODCALLTYPE OMSetDepthStencilState(ID3D11DepthStencilState* pDepthStencilState, UINT StencilRef){this->m_pImpl->OMSetDepthStencilState(pDepthStencilState, StencilRef); }
|
|
void STDMETHODCALLTYPE SOSetTargets(UINT NumBuffers, ID3D11Buffer* const* ppSOTargets, const UINT* pOffsets){this->m_pImpl->SOSetTargets(NumBuffers, ppSOTargets, pOffsets); }
|
|
void STDMETHODCALLTYPE DrawAuto(void){this->m_pImpl->DrawAuto(); }
|
|
void STDMETHODCALLTYPE DrawIndexedInstancedIndirect(ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs){this->m_pImpl->DrawIndexedInstancedIndirect(pBufferForArgs, AlignedByteOffsetForArgs); }
|
|
void STDMETHODCALLTYPE DrawInstancedIndirect(ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs){this->m_pImpl->DrawInstancedIndirect(pBufferForArgs, AlignedByteOffsetForArgs); }
|
|
void STDMETHODCALLTYPE Dispatch(UINT ThreadGroupCountX, UINT ThreadGroupCountY, UINT ThreadGroupCountZ){this->m_pImpl->Dispatch(ThreadGroupCountX, ThreadGroupCountY, ThreadGroupCountZ); }
|
|
void STDMETHODCALLTYPE DispatchIndirect(ID3D11Buffer* pBufferForArgs, UINT AlignedByteOffsetForArgs){this->m_pImpl->DispatchIndirect(pBufferForArgs, AlignedByteOffsetForArgs); }
|
|
void STDMETHODCALLTYPE RSSetState(ID3D11RasterizerState* pRasterizerState){this->m_pImpl->RSSetState(pRasterizerState); }
|
|
void STDMETHODCALLTYPE RSSetViewports(UINT NumViewports, const D3D11_VIEWPORT* pViewports){this->m_pImpl->RSSetViewports(NumViewports, pViewports); }
|
|
void STDMETHODCALLTYPE RSSetScissorRects(UINT NumRects, const D3D11_RECT* pRects){this->m_pImpl->RSSetScissorRects(NumRects, pRects); }
|
|
void STDMETHODCALLTYPE CopySubresourceRegion(ID3D11Resource* pDstResource, UINT DstSubresource, UINT DstX, UINT DstY, UINT DstZ, ID3D11Resource* pSrcResource, UINT SrcSubresource, const D3D11_BOX* pSrcBox){this->m_pImpl->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); }
|
|
void STDMETHODCALLTYPE CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource){this->m_pImpl->CopyResource(pDstResource, pSrcResource); }
|
|
void STDMETHODCALLTYPE UpdateSubresource(ID3D11Resource* pDstResource, UINT DstSubresource, const D3D11_BOX* pDstBox, const void* pSrcData, UINT SrcRowPitch, UINT SrcDepthPitch){this->m_pImpl->UpdateSubresource(pDstResource, DstSubresource, pDstBox, pSrcData, SrcRowPitch, SrcDepthPitch); }
|
|
void STDMETHODCALLTYPE CopyStructureCount(ID3D11Buffer* pDstBuffer, UINT DstAlignedByteOffset, ID3D11UnorderedAccessView* pSrcView){this->m_pImpl->CopyStructureCount(pDstBuffer, DstAlignedByteOffset, pSrcView); }
|
|
void STDMETHODCALLTYPE ClearRenderTargetView(ID3D11RenderTargetView* pRenderTargetView, const FLOAT ColorRGBA[ 4 ]){this->m_pImpl->ClearRenderTargetView(pRenderTargetView, ColorRGBA); }
|
|
void STDMETHODCALLTYPE ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUnorderedAccessView, const UINT Values[ 4 ]){this->m_pImpl->ClearUnorderedAccessViewUint(pUnorderedAccessView, Values); }
|
|
void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUnorderedAccessView, const FLOAT Values[ 4 ]){this->m_pImpl->ClearUnorderedAccessViewFloat(pUnorderedAccessView, Values); }
|
|
void STDMETHODCALLTYPE ClearDepthStencilView(ID3D11DepthStencilView* pDepthStencilView, UINT ClearFlags, FLOAT Depth, UINT8 Stencil){this->m_pImpl->ClearDepthStencilView(pDepthStencilView, ClearFlags, Depth, Stencil); }
|
|
void STDMETHODCALLTYPE GenerateMips(ID3D11ShaderResourceView* pShaderResourceView){this->m_pImpl->GenerateMips(pShaderResourceView); }
|
|
void STDMETHODCALLTYPE SetResourceMinLOD(ID3D11Resource* pResource, FLOAT MinLOD){this->m_pImpl->SetResourceMinLOD(pResource, MinLOD); }
|
|
FLOAT STDMETHODCALLTYPE GetResourceMinLOD(ID3D11Resource* pResource){return this->m_pImpl->GetResourceMinLOD(pResource); }
|
|
void STDMETHODCALLTYPE ResolveSubresource(ID3D11Resource* pDstResource, UINT DstSubresource, ID3D11Resource* pSrcResource, UINT SrcSubresource, DXGI_FORMAT Format){this->m_pImpl->ResolveSubresource(pDstResource, DstSubresource, pSrcResource, SrcSubresource, Format); }
|
|
void STDMETHODCALLTYPE ExecuteCommandList(ID3D11CommandList* pCommandList, BOOL RestoreContextState){this->m_pImpl->ExecuteCommandList(pCommandList, RestoreContextState); }
|
|
void STDMETHODCALLTYPE HSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews){this->m_pImpl->HSSetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE HSSetShader(ID3D11HullShader* pHullShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances){this->m_pImpl->HSSetShader(pHullShader, ppClassInstances, NumClassInstances); }
|
|
void STDMETHODCALLTYPE HSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers){this->m_pImpl->HSSetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE HSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers){this->m_pImpl->HSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE DSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews){this->m_pImpl->DSSetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE DSSetShader(ID3D11DomainShader* pDomainShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances){this->m_pImpl->DSSetShader(pDomainShader, ppClassInstances, NumClassInstances); }
|
|
void STDMETHODCALLTYPE DSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers){this->m_pImpl->DSSetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE DSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers){this->m_pImpl->DSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE CSSetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView* const* ppShaderResourceViews){this->m_pImpl->CSSetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE CSSetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs, ID3D11UnorderedAccessView* const* ppUnorderedAccessViews, const UINT* pUAVInitialCounts){this->m_pImpl->CSSetUnorderedAccessViews(StartSlot, NumUAVs, ppUnorderedAccessViews, pUAVInitialCounts); }
|
|
void STDMETHODCALLTYPE CSSetShader(ID3D11ComputeShader* pComputeShader, ID3D11ClassInstance* const* ppClassInstances, UINT NumClassInstances){this->m_pImpl->CSSetShader(pComputeShader, ppClassInstances, NumClassInstances); }
|
|
void STDMETHODCALLTYPE CSSetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState* const* ppSamplers){this->m_pImpl->CSSetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE CSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer* const* ppConstantBuffers){this->m_pImpl->CSSetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE VSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers){this->m_pImpl->VSGetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE PSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews){this->m_pImpl->PSGetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE PSGetShader(ID3D11PixelShader** ppPixelShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances){this->m_pImpl->PSGetShader(ppPixelShader, ppClassInstances, pNumClassInstances); }
|
|
void STDMETHODCALLTYPE PSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers){this->m_pImpl->PSGetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE VSGetShader(ID3D11VertexShader** ppVertexShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances){this->m_pImpl->VSGetShader(ppVertexShader, ppClassInstances, pNumClassInstances); }
|
|
void STDMETHODCALLTYPE PSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers){this->m_pImpl->PSGetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE IAGetInputLayout(ID3D11InputLayout** ppInputLayout){this->m_pImpl->IAGetInputLayout(ppInputLayout); }
|
|
void STDMETHODCALLTYPE IAGetVertexBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppVertexBuffers, UINT* pStrides, UINT* pOffsets){this->m_pImpl->IAGetVertexBuffers(StartSlot, NumBuffers, ppVertexBuffers, pStrides, pOffsets); }
|
|
void STDMETHODCALLTYPE IAGetIndexBuffer(ID3D11Buffer** pIndexBuffer, DXGI_FORMAT* Format, UINT* Offset){this->m_pImpl->IAGetIndexBuffer(pIndexBuffer, Format, Offset); }
|
|
void STDMETHODCALLTYPE GSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers){this->m_pImpl->GSGetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE GSGetShader(ID3D11GeometryShader** ppGeometryShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances){this->m_pImpl->GSGetShader(ppGeometryShader, ppClassInstances, pNumClassInstances); }
|
|
void STDMETHODCALLTYPE IAGetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY* pTopology){this->m_pImpl->IAGetPrimitiveTopology(pTopology); }
|
|
void STDMETHODCALLTYPE VSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews){this->m_pImpl->VSGetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE VSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers){this->m_pImpl->VSGetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE GetPredication(ID3D11Predicate** ppPredicate, BOOL* pPredicateValue){this->m_pImpl->GetPredication(ppPredicate, pPredicateValue); }
|
|
void STDMETHODCALLTYPE GSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews){this->m_pImpl->GSGetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE GSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers){this->m_pImpl->GSGetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE OMGetRenderTargets(UINT NumViews, ID3D11RenderTargetView** ppRenderTargetViews, ID3D11DepthStencilView** ppDepthStencilView){this->m_pImpl->OMGetRenderTargets(NumViews, ppRenderTargetViews, ppDepthStencilView); }
|
|
void STDMETHODCALLTYPE OMGetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, ID3D11RenderTargetView** ppRenderTargetViews, ID3D11DepthStencilView** ppDepthStencilView, UINT UAVStartSlot, UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews){this->m_pImpl->OMGetRenderTargetsAndUnorderedAccessViews(NumRTVs, ppRenderTargetViews, ppDepthStencilView, UAVStartSlot, NumUAVs, ppUnorderedAccessViews); }
|
|
void STDMETHODCALLTYPE OMGetBlendState(ID3D11BlendState** ppBlendState, FLOAT BlendFactor[ 4 ], UINT* pSampleMask){this->m_pImpl->OMGetBlendState(ppBlendState, BlendFactor, pSampleMask); }
|
|
void STDMETHODCALLTYPE OMGetDepthStencilState(ID3D11DepthStencilState** ppDepthStencilState, UINT* pStencilRef){this->m_pImpl->OMGetDepthStencilState(ppDepthStencilState, pStencilRef); }
|
|
void STDMETHODCALLTYPE SOGetTargets(UINT NumBuffers, ID3D11Buffer** ppSOTargets){this->m_pImpl->SOGetTargets(NumBuffers, ppSOTargets); }
|
|
void STDMETHODCALLTYPE RSGetState(ID3D11RasterizerState** ppRasterizerState){this->m_pImpl->RSGetState(ppRasterizerState); }
|
|
void STDMETHODCALLTYPE RSGetViewports(UINT* pNumViewports, D3D11_VIEWPORT* pViewports){this->m_pImpl->RSGetViewports(pNumViewports, pViewports); }
|
|
void STDMETHODCALLTYPE RSGetScissorRects(UINT* pNumRects, D3D11_RECT* pRects){this->m_pImpl->RSGetScissorRects(pNumRects, pRects); }
|
|
void STDMETHODCALLTYPE HSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews){this->m_pImpl->HSGetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE HSGetShader(ID3D11HullShader** ppHullShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances){this->m_pImpl->HSGetShader(ppHullShader, ppClassInstances, pNumClassInstances); }
|
|
void STDMETHODCALLTYPE HSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers){this->m_pImpl->HSGetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE HSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers){this->m_pImpl->HSGetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE DSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews){this->m_pImpl->DSGetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE DSGetShader(ID3D11DomainShader** ppDomainShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances){this->m_pImpl->DSGetShader(ppDomainShader, ppClassInstances, pNumClassInstances); }
|
|
void STDMETHODCALLTYPE DSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers){this->m_pImpl->DSGetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE DSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers){this->m_pImpl->DSGetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE CSGetShaderResources(UINT StartSlot, UINT NumViews, ID3D11ShaderResourceView** ppShaderResourceViews){this->m_pImpl->CSGetShaderResources(StartSlot, NumViews, ppShaderResourceViews); }
|
|
void STDMETHODCALLTYPE CSGetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs, ID3D11UnorderedAccessView** ppUnorderedAccessViews){this->m_pImpl->CSGetUnorderedAccessViews(StartSlot, NumUAVs, ppUnorderedAccessViews); }
|
|
void STDMETHODCALLTYPE CSGetShader(ID3D11ComputeShader** ppComputeShader, ID3D11ClassInstance** ppClassInstances, UINT* pNumClassInstances){this->m_pImpl->CSGetShader(ppComputeShader, ppClassInstances, pNumClassInstances); }
|
|
void STDMETHODCALLTYPE CSGetSamplers(UINT StartSlot, UINT NumSamplers, ID3D11SamplerState** ppSamplers){this->m_pImpl->CSGetSamplers(StartSlot, NumSamplers, ppSamplers); }
|
|
void STDMETHODCALLTYPE CSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, ID3D11Buffer** ppConstantBuffers){this->m_pImpl->CSGetConstantBuffers(StartSlot, NumBuffers, ppConstantBuffers); }
|
|
void STDMETHODCALLTYPE ClearState(void){this->m_pImpl->ClearState(); }
|
|
void STDMETHODCALLTYPE Flush(void){this->m_pImpl->Flush(); }
|
|
D3D11_DEVICE_CONTEXT_TYPE STDMETHODCALLTYPE GetType(void){return this->m_pImpl->GetType(); }
|
|
UINT STDMETHODCALLTYPE GetContextFlags(void){return this->m_pImpl->GetContextFlags(); }
|
|
HRESULT STDMETHODCALLTYPE FinishCommandList(BOOL RestoreDeferredContextState, ID3D11CommandList** ppCommandList){return this->m_pImpl->FinishCommandList(RestoreDeferredContextState, ppCommandList); }
|
|
};
|
|
} //namespace NDXGLWrappers
|
|
|
|
#undef DXGL_WRAPPER_ROOT_NO_COM
|
|
#undef DXGL_WRAPPER_ROOT
|
|
#undef DXGL_WRAPPER_DERIVED
|
|
|
|
#define DXGL_IMPLEMENT_INTERFACE(_Class, _Interface) \
|
|
typedef NDXGLWrappers::S ## _Interface<_Class, I ## _Interface> T ## _Interface ## Wrapper; \
|
|
T ## _Interface ## Wrapper m_k ## _Interface ## Wrapper; \
|
|
I ## _Interface * m_pVirtual ## _Interface ## Wrapper; \
|
|
static void ToInterface(I ## _Interface * *ppInterface, _Class * pObject) \
|
|
{ \
|
|
*ppInterface = (pObject == NULL ? NULL : pObject->m_pVirtual ## _Interface ## Wrapper); \
|
|
} \
|
|
static _Class* FromInterface(I ## _Interface * pInterface) \
|
|
{ \
|
|
return pInterface == NULL ? NULL : static_cast<T ## _Interface ## Wrapper*>(pInterface)->m_pImpl; \
|
|
}
|
|
#define DXGL_INITIALIZE_INTERFACE(_Interface) \
|
|
m_k ## _Interface ## Wrapper.InitializeWrapper(this);
|
|
|
|
#else
|
|
|
|
#define DXGL_IMPLEMENT_INTERFACE(_Class, _Interface) \
|
|
static void ToInterface(I ## _Interface * *ppInterface, _Class * pObject) \
|
|
{ \
|
|
*ppInterface = pObject; \
|
|
} \
|
|
static _Class* FromInterface(I ## _Interface * pInterface) \
|
|
{ \
|
|
return static_cast<_Class*>(pInterface); \
|
|
}
|
|
#define DXGL_INITIALIZE_INTERFACE(_Interface)
|
|
|
|
#endif
|
|
|
|
#endif //__DXEmulation__
|