extern const char* sm4_opcode_names[];
extern const char* sm4_file_names[];
-extern const char* sm4_file_ms_names[];
+extern const char* sm4_shortfile_names[];
extern const char* sm4_target_names[];
extern const char* sm4_interpolation_names[];
extern const char* sm4_sv_names[];
#define WIN32_LEAN_AND_MEAN
#include <objbase.h>
-#include <specstrings.h>
#include "galliumdxgi.h"
#include <d3dcommon.h>
}
HRESULT get_private_data(
- __in REFGUID guid,
- __inout UINT *pDataSize,
- __out_bcount_opt(*pDataSize) void *pData)
+ REFGUID guid,
+ UINT *pDataSize,
+ void *pData)
{
lock_t<mutex_t> lock(private_data_mutex);
private_data_map_t::iterator i = private_data_map.find(guid);
}
HRESULT set_private_data(
- __in REFGUID guid,
- __in UINT DataSize,
- __in_bcount_opt( DataSize ) const void *pData)
+ REFGUID guid,
+ UINT DataSize,
+ const void *pData)
{
void* p = 0;
}
HRESULT set_private_data_interface(
- __in REFGUID guid,
- __in_opt const IUnknown *pData)
+ REFGUID guid,
+ const IUnknown *pData)
{
lock_t<mutex_t> lock(private_data_mutex);
std::pair<void*, unsigned>& v = private_data_map[guid];
}
virtual HRESULT STDMETHODCALLTYPE GetPrivateData(
- __in REFGUID guid,
- __inout UINT *pDataSize,
- __out_bcount_opt(*pDataSize) void *pData)
+ REFGUID guid,
+ UINT *pDataSize,
+ void *pData)
{
return get_private_data(guid, pDataSize, pData);
}
virtual HRESULT STDMETHODCALLTYPE SetPrivateData(
- __in REFGUID guid,
- __in UINT DataSize,
- __in_bcount_opt( DataSize ) const void *pData)
+ REFGUID guid,
+ UINT DataSize,
+ const void *pData)
{
return set_private_data(guid, DataSize, pData);
}
virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
- __in REFGUID guid,
- __in_opt const IUnknown *pData)
+ REFGUID guid,
+ const IUnknown *pData)
{
return set_private_data_interface(guid, pData);
}
{
// we could avoid this duplication, but the increased complexity to do so isn't worth it
virtual HRESULT STDMETHODCALLTYPE GetPrivateData(
- __in REFGUID guid,
- __inout UINT *pDataSize,
- __out_bcount_opt(*pDataSize) void *pData)
+ REFGUID guid,
+ UINT *pDataSize,
+ void *pData)
{
return BaseClass::get_private_data(guid, pDataSize, pData);
}
virtual HRESULT STDMETHODCALLTYPE SetPrivateData(
- __in REFGUID guid,
- __in UINT DataSize,
- __in_bcount_opt( DataSize ) const void *pData)
+ REFGUID guid,
+ UINT DataSize,
+ const void *pData)
{
return BaseClass::set_private_data(guid, DataSize, pData);
}
virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
- __in REFGUID guid,
- __in_opt const IUnknown *pData)
+ REFGUID guid,
+ const IUnknown *pData)
{
return BaseClass::set_private_data_interface(guid, pData);
}
}
virtual HRESULT STDMETHODCALLTYPE GetParent(
- __in REFIID riid,
- __out void **ppParent)
+ REFIID riid,
+ void **ppParent)
{
return adapter.p->QueryInterface(riid, ppParent);
}
virtual HRESULT STDMETHODCALLTYPE GetAdapter(
- __out IDXGIAdapter **pAdapter)
+ IDXGIAdapter **pAdapter)
{
*pAdapter = adapter.ref();
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE QueryResourceResidency(
- __in_ecount(NumResources) IUnknown *const *ppResources,
- __out_ecount(NumResources) DXGI_RESIDENCY *pResidencyStatus,
+ IUnknown *const *ppResources,
+ DXGI_RESIDENCY *pResidencyStatus,
UINT NumResources)
{
for(unsigned i = 0; i < NumResources; ++i)
}
virtual HRESULT STDMETHODCALLTYPE GetGPUThreadPriority(
- __out INT *pPriority)
+ INT *pPriority)
{
*pPriority = priority;
return S_OK;
+++ /dev/null
-#ifndef SPECSTRINGS_H
-#define SPECSTRINGS_H
-
-#define __in
-#define __in_opt
-#define __out
-#define __out_opt
-#define __inout
-#define __inout_opt
-#define __in_bcount(...)
-#define __in_bcount_opt(...)
-#define __in_ecount(...)
-#define __in_ecount_opt(...)
-#define __in_xcount(...)
-#define __in_xcount_opt(...)
-#define __out_bcount(...)
-#define __out_bcount_opt(...)
-#define __out_ecount(...)
-#define __out_ecount_opt(...)
-#define __out_ecount_part_opt(...)
-#define __in_range(...)
-#define __inout_range(...)
-#define __out_range(...)
-
-#endif
}
virtual HRESULT STDMETHODCALLTYPE GetParent(
- __in REFIID riid,
- __out void **ppParent)
+ REFIID riid,
+ void **ppParent)
{
return parent->QueryInterface(riid, ppParent);
}
virtual HRESULT STDMETHODCALLTYPE EnumAdapters(
UINT Adapter,
- __out IDXGIAdapter **ppAdapter)
+ IDXGIAdapter **ppAdapter)
{
return EnumAdapters1(Adapter, (IDXGIAdapter1**)ppAdapter);
}
virtual HRESULT STDMETHODCALLTYPE EnumAdapters1(
UINT Adapter,
- __out IDXGIAdapter1 **ppAdapter)
+ IDXGIAdapter1 **ppAdapter)
{
*ppAdapter = 0;
if(Adapter == 0)
}
virtual HRESULT STDMETHODCALLTYPE GetWindowAssociation(
- __out HWND *pWindowHandle)
+ HWND *pWindowHandle)
{
*pWindowHandle = associated_window;
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE CreateSwapChain(
- __in IUnknown *pDevice,
- __in DXGI_SWAP_CHAIN_DESC *pDesc,
- __out IDXGISwapChain **ppSwapChain)
+ IUnknown *pDevice,
+ DXGI_SWAP_CHAIN_DESC *pDesc,
+ IDXGISwapChain **ppSwapChain)
{
return GalliumDXGISwapChainCreate(this, pDevice, *pDesc, ppSwapChain);
}
virtual HRESULT STDMETHODCALLTYPE CreateSoftwareAdapter(
HMODULE Module,
- __out IDXGIAdapter **ppAdapter)
+ IDXGIAdapter **ppAdapter)
{
/* TODO: ignore the module, and just create a Gallium software screen */
*ppAdapter = 0;
virtual HRESULT STDMETHODCALLTYPE EnumOutputs(
UINT Output,
- __out IDXGIOutput **ppOutput)
+ IDXGIOutput **ppOutput)
{
if(Output >= (unsigned)num_outputs)
return DXGI_ERROR_NOT_FOUND;
}
virtual HRESULT STDMETHODCALLTYPE GetDesc(
- __out DXGI_ADAPTER_DESC *pDesc)
+ DXGI_ADAPTER_DESC *pDesc)
{
memcpy(pDesc, &desc, sizeof(*pDesc));
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetDesc1(
- __out DXGI_ADAPTER_DESC1 *pDesc)
+ DXGI_ADAPTER_DESC1 *pDesc)
{
memcpy(pDesc, &desc, sizeof(*pDesc));
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE CheckInterfaceSupport(
- __in REFGUID InterfaceName,
- __out LARGE_INTEGER *pUMDVersion)
+ REFGUID InterfaceName,
+ LARGE_INTEGER *pUMDVersion)
{
// these number was taken from Windows 7 with Catalyst 10.8: its meaning is unclear
if(InterfaceName == IID_ID3D11Device || InterfaceName == IID_ID3D10Device1 || InterfaceName == IID_ID3D10Device)
}
virtual HRESULT STDMETHODCALLTYPE GetDesc(
- __out DXGI_OUTPUT_DESC *pDesc)
+ DXGI_OUTPUT_DESC *pDesc)
{
*pDesc = desc;
return S_OK;
virtual HRESULT STDMETHODCALLTYPE GetDisplayModeList(
DXGI_FORMAT EnumFormat,
UINT Flags,
- __inout UINT *pNumModes,
- __out_ecount_part_opt(*pNumModes,*pNumModes) DXGI_MODE_DESC *pDesc)
+ UINT *pNumModes,
+ DXGI_MODE_DESC *pDesc)
{
/* TODO: should we return DXGI_ERROR_NOT_CURRENTLY_AVAILABLE when we don't
* support modesetting instead of fake modes?
}
virtual HRESULT STDMETHODCALLTYPE FindClosestMatchingMode(
- __in const DXGI_MODE_DESC *pModeToMatch,
- __out DXGI_MODE_DESC *pClosestMatch,
- __in_opt IUnknown *pConcernedDevice)
+ const DXGI_MODE_DESC *pModeToMatch,
+ DXGI_MODE_DESC *pClosestMatch,
+ IUnknown *pConcernedDevice)
{
/* TODO: actually implement this */
DXGI_FORMAT dxgi_format = pModeToMatch->Format;
}
virtual HRESULT STDMETHODCALLTYPE TakeOwnership(
- __in IUnknown *pDevice,
+ IUnknown *pDevice,
BOOL Exclusive)
{
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetGammaControlCapabilities(
- __out DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps)
+ DXGI_GAMMA_CONTROL_CAPABILITIES *pGammaCaps)
{
memset(pGammaCaps, 0, sizeof(*pGammaCaps));
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE SetGammaControl(
- __in const DXGI_GAMMA_CONTROL *pArray)
+ const DXGI_GAMMA_CONTROL *pArray)
{
if(!gamma)
gamma = new DXGI_GAMMA_CONTROL;
}
virtual HRESULT STDMETHODCALLTYPE GetGammaControl(
- __out DXGI_GAMMA_CONTROL *pArray)
+ DXGI_GAMMA_CONTROL *pArray)
{
if(gamma)
*pArray = *gamma;
}
virtual HRESULT STDMETHODCALLTYPE SetDisplaySurface(
- __in IDXGISurface *pScanoutSurface)
+ IDXGISurface *pScanoutSurface)
{
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE GetDisplaySurfaceData(
- __in IDXGISurface *pDestination)
+ IDXGISurface *pDestination)
{
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE GetFrameStatistics(
- __out DXGI_FRAME_STATISTICS *pStats)
+ DXGI_FRAME_STATISTICS *pStats)
{
memset(pStats, 0, sizeof(*pStats));
#ifdef _WIN32
}
virtual HRESULT STDMETHODCALLTYPE GetDevice(
- __in REFIID riid,
- __out void **ppDevice)
+ REFIID riid,
+ void **ppDevice)
{
return dxgi_device->QueryInterface(riid, ppDevice);
}
virtual HRESULT STDMETHODCALLTYPE GetBuffer(
UINT Buffer,
- __in REFIID riid,
- __out void **ppSurface)
+ REFIID riid,
+ void **ppSurface)
{
if(Buffer > 0)
{
/* TODO: implement somehow */
virtual HRESULT STDMETHODCALLTYPE SetFullscreenState(
BOOL Fullscreen,
- __in_opt IDXGIOutput *pTarget)
+ IDXGIOutput *pTarget)
{
fullscreen = Fullscreen;
target = pTarget;
}
virtual HRESULT STDMETHODCALLTYPE GetFullscreenState(
- __out BOOL *pFullscreen,
- __out IDXGIOutput **ppTarget)
+ BOOL *pFullscreen,
+ IDXGIOutput **ppTarget)
{
if(pFullscreen)
*pFullscreen = fullscreen;
}
virtual HRESULT STDMETHODCALLTYPE GetDesc(
- __out DXGI_SWAP_CHAIN_DESC *pDesc)
+ DXGI_SWAP_CHAIN_DESC *pDesc)
{
*pDesc = desc;
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetContainingOutput(
- __out IDXGIOutput **ppOutput)
+ IDXGIOutput **ppOutput)
{
*ppOutput = adapter->outputs[0].ref();
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetFrameStatistics(
- __out DXGI_FRAME_STATISTICS *pStats)
+ DXGI_FRAME_STATISTICS *pStats)
{
memset(pStats, 0, sizeof(*pStats));
#ifdef _WIN32
}
virtual HRESULT STDMETHODCALLTYPE GetLastPresentCount(
- __out UINT *pLastPresentCount)
+ UINT *pLastPresentCount)
{
*pLastPresentCount = present_count;
return S_OK;
* Or perhaps what they actually mean is "only create a single factory in your application"?
* TODO: should we use a singleton here, so we never have multiple DXGI objects for the same thing? */
HRESULT STDMETHODCALLTYPE CreateDXGIFactory1(
- __in REFIID riid,
- __out void **ppFactory
+ REFIID riid,
+ void **ppFactory
)
{
GalliumDXGIFactory* factory;
}
HRESULT STDMETHODCALLTYPE CreateDXGIFactory(
- __in REFIID riid,
- __out void **ppFactory
+ REFIID riid,
+ void **ppFactory
)
{
return CreateDXGIFactory1(riid, ppFactory);
#include <pipe/p_context.h>
HRESULT D3D10CreateDevice1(
- __in_opt IDXGIAdapter *pAdapter,
- __in D3D10_DRIVER_TYPE DriverType,
- __in HMODULE Software,
- __in unsigned Flags,
- __in D3D10_FEATURE_LEVEL1 HardwareLevel,
- __in unsigned SDKVersion,
- __out_opt ID3D10Device1 **ppDevice
+ IDXGIAdapter *pAdapter,
+ D3D10_DRIVER_TYPE DriverType,
+ HMODULE Software,
+ unsigned Flags,
+ D3D10_FEATURE_LEVEL1 HardwareLevel,
+ unsigned SDKVersion,
+ ID3D10Device1 **ppDevice
)
{
HRESULT hr;
}
HRESULT WINAPI D3D10CreateDeviceAndSwapChain1(
- __in_opt IDXGIAdapter* pAdapter,
+ IDXGIAdapter* pAdapter,
D3D10_DRIVER_TYPE DriverType,
HMODULE Software,
unsigned Flags,
- __in D3D10_FEATURE_LEVEL1 HardwareLevel,
+ D3D10_FEATURE_LEVEL1 HardwareLevel,
unsigned SDKVersion,
- __in_opt DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
- __out_opt IDXGISwapChain** ppSwapChain,
- __out_opt ID3D10Device1** ppDevice
+ DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
+ IDXGISwapChain** ppSwapChain,
+ ID3D10Device1** ppDevice
)
{
ComPtr<ID3D10Device1> dev;
}
HRESULT D3D10CreateDevice(
- __in_opt IDXGIAdapter *pAdapter,
- __in D3D10_DRIVER_TYPE DriverType,
- __in HMODULE Software,
- __in unsigned Flags,
- __in unsigned SDKVersion,
- __out_opt ID3D10Device **ppDevice
+ IDXGIAdapter *pAdapter,
+ D3D10_DRIVER_TYPE DriverType,
+ HMODULE Software,
+ unsigned Flags,
+ unsigned SDKVersion,
+ ID3D10Device **ppDevice
)
{
return D3D10CreateDevice1(pAdapter, DriverType, Software, Flags, D3D10_FEATURE_LEVEL_10_0, SDKVersion, (ID3D10Device1**)ppDevice);
}
HRESULT WINAPI D3D10CreateDeviceAndSwapChain(
- __in_opt IDXGIAdapter* pAdapter,
+ IDXGIAdapter* pAdapter,
D3D10_DRIVER_TYPE DriverType,
HMODULE Software,
unsigned Flags,
unsigned SDKVersion,
- __in_opt DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
- __out_opt IDXGISwapChain** ppSwapChain,
- __out_opt ID3D10Device** ppDevice
+ DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
+ IDXGISwapChain** ppSwapChain,
+ ID3D10Device** ppDevice
)
{
return D3D10CreateDeviceAndSwapChain1(pAdapter, DriverType, Software, Flags, D3D10_FEATURE_LEVEL_10_0, SDKVersion, pSwapChainDesc, ppSwapChain, (ID3D10Device1**)ppDevice);
#include <pipe/p_context.h>
HRESULT D3D11CreateDevice(
- __in_opt IDXGIAdapter *pAdapter,
- __in D3D_DRIVER_TYPE DriverType,
- __in HMODULE Software,
- __in unsigned Flags,
- __in_ecount_opt( FeatureLevels ) const D3D_FEATURE_LEVEL *pFeatureLevels,
- __in unsigned FeatureLevels,
- __in unsigned SDKVersion,
- __out_opt ID3D11Device **ppDevice,
- __out_opt D3D_FEATURE_LEVEL *pFeatureLevel,
- __out_opt ID3D11DeviceContext **ppImmediateContext
+ IDXGIAdapter *pAdapter,
+ D3D_DRIVER_TYPE DriverType,
+ HMODULE Software,
+ unsigned Flags,
+ const D3D_FEATURE_LEVEL *pFeatureLevels,
+ unsigned FeatureLevels,
+ unsigned SDKVersion,
+ ID3D11Device **ppDevice,
+ D3D_FEATURE_LEVEL *pFeatureLevel,
+ ID3D11DeviceContext **ppImmediateContext
)
{
HRESULT hr;
}
HRESULT WINAPI D3D11CreateDeviceAndSwapChain(
- __in_opt IDXGIAdapter* pAdapter,
+ IDXGIAdapter* pAdapter,
D3D_DRIVER_TYPE DriverType,
HMODULE Software,
unsigned Flags,
- __in_ecount_opt( FeatureLevels ) CONST D3D_FEATURE_LEVEL* pFeatureLevels,
+ CONST D3D_FEATURE_LEVEL* pFeatureLevels,
unsigned FeatureLevels,
unsigned SDKVersion,
- __in_opt CONST DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
- __out_opt IDXGISwapChain** ppSwapChain,
- __out_opt ID3D11Device** ppDevice,
- __out_opt D3D_FEATURE_LEVEL* pFeatureLevel,
- __out_opt ID3D11DeviceContext** ppImmediateContext )
+ CONST DXGI_SWAP_CHAIN_DESC* pSwapChainDesc,
+ IDXGISwapChain** ppSwapChain,
+ ID3D11Device** ppDevice,
+ D3D_FEATURE_LEVEL* pFeatureLevel,
+ ID3D11DeviceContext** ppImmediateContext )
{
ComPtr<ID3D11Device> dev;
ComPtr<ID3D11DeviceContext> ctx;
#if API < 11
// we use a D3D11-like API internally
virtual HRESULT STDMETHODCALLTYPE Map(
- __in ID3D11Resource *pResource,
- __in unsigned Subresource,
- __in D3D11_MAP MapType,
- __in unsigned MapFlags,
- __out D3D11_MAPPED_SUBRESOURCE *pMappedResource) = 0;
+ ID3D11Resource *pResource,
+ unsigned Subresource,
+ D3D11_MAP MapType,
+ unsigned MapFlags,
+ D3D11_MAPPED_SUBRESOURCE *pMappedResource) = 0;
virtual void STDMETHODCALLTYPE Unmap(
- __in ID3D11Resource *pResource,
- __in unsigned Subresource) = 0;
+ ID3D11Resource *pResource,
+ unsigned Subresource) = 0;
virtual void STDMETHODCALLTYPE Begin(
- __in ID3D11Asynchronous *pAsync) = 0;
+ ID3D11Asynchronous *pAsync) = 0;
virtual void STDMETHODCALLTYPE End(
- __in ID3D11Asynchronous *pAsync) = 0;
+ ID3D11Asynchronous *pAsync) = 0;
virtual HRESULT STDMETHODCALLTYPE GetData(
- __in ID3D11Asynchronous *pAsync,
- __out_bcount_opt(DataSize) void *pData,
- __in unsigned DataSize,
- __in unsigned GetDataFlags) = 0;
+ ID3D11Asynchronous *pAsync,
+ void *pData,
+ unsigned DataSize,
+ unsigned GetDataFlags) = 0;
// TODO: maybe we should use function overloading, but that might risk silent errors,
// and cannot be exported to a C interface
}
#if API >= 11
#define SET_SHADER_EXTRA_ARGS , \
- __in_ecount_opt(NumClassInstances) ID3D11ClassInstance *const *ppClassInstances, \
+ ID3D11ClassInstance *const *ppClassInstances, \
unsigned NumClassInstances
#define GET_SHADER_EXTRA_ARGS , \
- __out_ecount_opt(*pNumClassInstances) ID3D11ClassInstance **ppClassInstances, \
- __inout_opt unsigned *pNumClassInstances
+ ID3D11ClassInstance **ppClassInstances, \
+ unsigned *pNumClassInstances
#else
#define SET_SHADER_EXTRA_ARGS
#define GET_SHADER_EXTRA_ARGS
#define IMPLEMENT_SHADER_STAGE(XS, Stage) \
virtual void STDMETHODCALLTYPE XS##SetShader( \
- __in_opt ID3D11##Stage##Shader *pShader \
+ ID3D11##Stage##Shader *pShader \
SET_SHADER_EXTRA_ARGS) \
{ \
SYNCHRONIZED; \
xs_set_shader<D3D11_STAGE_##XS>((GalliumD3D11Shader<>*)pShader); \
} \
virtual void STDMETHODCALLTYPE XS##GetShader(\
- __out ID3D11##Stage##Shader **ppShader \
+ ID3D11##Stage##Shader **ppShader \
GET_SHADER_EXTRA_ARGS) \
{ \
SYNCHRONIZED; \
*ppShader = (ID3D11##Stage##Shader*)shaders[D3D11_STAGE_##XS].ref(); \
} \
virtual void STDMETHODCALLTYPE XS##SetConstantBuffers(\
- __in_range(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1) unsigned StartSlot, \
- __in_range(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot) unsigned NumBuffers, \
- __in_ecount(NumBuffers) ID3D11Buffer *const *ppConstantBuffers) \
+ unsigned StartSlot, \
+ unsigned NumBuffers, \
+ ID3D11Buffer *const *ppConstantBuffers) \
{ \
SYNCHRONIZED; \
xs_set_constant_buffers<D3D11_STAGE_##XS>(StartSlot, NumBuffers, (GalliumD3D11Buffer *const *)ppConstantBuffers); \
} \
virtual void STDMETHODCALLTYPE XS##GetConstantBuffers(\
- __in_range(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - 1) unsigned StartSlot, \
- __in_range(0, D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT - StartSlot) unsigned NumBuffers, \
- __out_ecount(NumBuffers) ID3D11Buffer **ppConstantBuffers) \
+ unsigned StartSlot, \
+ unsigned NumBuffers, \
+ ID3D11Buffer **ppConstantBuffers) \
{ \
SYNCHRONIZED; \
for(unsigned i = 0; i < NumBuffers; ++i) \
ppConstantBuffers[i] = constant_buffers[D3D11_STAGE_##XS][StartSlot + i].ref(); \
} \
virtual void STDMETHODCALLTYPE XS##SetShaderResources(\
- __in_range(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1) unsigned StartSlot, \
- __in_range(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot) unsigned NumViews, \
- __in_ecount(NumViews) ID3D11ShaderResourceView *const *ppShaderResourceViews) \
+ unsigned StartSlot, \
+ unsigned NumViews, \
+ ID3D11ShaderResourceView *const *ppShaderResourceViews) \
{ \
SYNCHRONIZED; \
xs_set_shader_resources<D3D11_STAGE_##XS>(StartSlot, NumViews, (GalliumD3D11ShaderResourceView *const *)ppShaderResourceViews); \
} \
virtual void STDMETHODCALLTYPE XS##GetShaderResources(\
- __in_range(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - 1) unsigned StartSlot, \
- __in_range(0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT - StartSlot) unsigned NumViews, \
- __out_ecount(NumViews) ID3D11ShaderResourceView **ppShaderResourceViews) \
+ unsigned StartSlot, \
+ unsigned NumViews, \
+ ID3D11ShaderResourceView **ppShaderResourceViews) \
{ \
SYNCHRONIZED; \
for(unsigned i = 0; i < NumViews; ++i) \
ppShaderResourceViews[i] = shader_resource_views[D3D11_STAGE_##XS][StartSlot + i].ref(); \
} \
virtual void STDMETHODCALLTYPE XS##SetSamplers(\
- __in_range(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1) unsigned StartSlot, \
- __in_range(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot) unsigned NumSamplers, \
- __in_ecount(NumSamplers) ID3D11SamplerState *const *ppSamplers) \
+ unsigned StartSlot, \
+ unsigned NumSamplers, \
+ ID3D11SamplerState *const *ppSamplers) \
{ \
SYNCHRONIZED; \
xs_set_samplers<D3D11_STAGE_##XS>(StartSlot, NumSamplers, (GalliumD3D11SamplerState *const *)ppSamplers); \
} \
virtual void STDMETHODCALLTYPE XS##GetSamplers( \
- __in_range(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - 1) unsigned StartSlot, \
- __in_range(0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT - StartSlot) unsigned NumSamplers, \
- __out_ecount(NumSamplers) ID3D11SamplerState **ppSamplers) \
+ unsigned StartSlot, \
+ unsigned NumSamplers, \
+ ID3D11SamplerState **ppSamplers) \
{ \
SYNCHRONIZED; \
for(unsigned i = 0; i < NumSamplers; ++i) \
IMPLEMENT_SHADER_STAGE(CS, Compute)
virtual void STDMETHODCALLTYPE CSSetUnorderedAccessViews(
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - 1) unsigned StartSlot,
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot) unsigned NumUAVs,
- __in_ecount(NumUAVs) ID3D11UnorderedAccessView *const *ppUnorderedAccessViews,
- __in_ecount(NumUAVs) const unsigned *pUAVInitialCounts)
+ unsigned StartSlot,
+ unsigned NumUAVs,
+ ID3D11UnorderedAccessView *const *ppUnorderedAccessViews,
+ const unsigned *pUAVInitialCounts)
{
SYNCHRONIZED;
for(unsigned i = 0; i < NumUAVs; ++i)
}
virtual void STDMETHODCALLTYPE CSGetUnorderedAccessViews(
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - 1) unsigned StartSlot,
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - StartSlot) unsigned NumUAVs,
- __out_ecount(NumUAVs) ID3D11UnorderedAccessView **ppUnorderedAccessViews)
+ unsigned StartSlot,
+ unsigned NumUAVs,
+ ID3D11UnorderedAccessView **ppUnorderedAccessViews)
{
SYNCHRONIZED;
for(unsigned i = 0; i < NumUAVs; ++i)
}
virtual void STDMETHODCALLTYPE IASetInputLayout(
- __in_opt ID3D11InputLayout *pInputLayout)
+ ID3D11InputLayout *pInputLayout)
{
SYNCHRONIZED;
if(pInputLayout != input_layout.p)
}
virtual void STDMETHODCALLTYPE IAGetInputLayout(
- __out ID3D11InputLayout **ppInputLayout)
+ ID3D11InputLayout **ppInputLayout)
{
SYNCHRONIZED;
*ppInputLayout = input_layout.ref();
}
virtual void STDMETHODCALLTYPE IASetVertexBuffers(
- __in_range(0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - 1) unsigned StartSlot,
- __in_range(0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - StartSlot) unsigned NumBuffers,
- __in_ecount(NumBuffers) ID3D11Buffer *const *ppVertexBuffers,
- __in_ecount(NumBuffers) const unsigned *pStrides,
- __in_ecount(NumBuffers) const unsigned *pOffsets)
+ unsigned StartSlot,
+ unsigned NumBuffers,
+ ID3D11Buffer *const *ppVertexBuffers,
+ const unsigned *pStrides,
+ const unsigned *pOffsets)
{
SYNCHRONIZED;
int last_different = -1;
}
virtual void STDMETHODCALLTYPE IAGetVertexBuffers(
- __in_range(0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - 1) unsigned StartSlot,
- __in_range(0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT - StartSlot) unsigned NumBuffers,
- __out_ecount_opt(NumBuffers) ID3D11Buffer **ppVertexBuffers,
- __out_ecount_opt(NumBuffers) unsigned *pStrides,
- __out_ecount_opt(NumBuffers) unsigned *pOffsets)
+ unsigned StartSlot,
+ unsigned NumBuffers,
+ ID3D11Buffer **ppVertexBuffers,
+ unsigned *pStrides,
+ unsigned *pOffsets)
{
SYNCHRONIZED;
if(ppVertexBuffers)
}
virtual void STDMETHODCALLTYPE IASetIndexBuffer(
- __in_opt ID3D11Buffer *pIndexBuffer,
- __in DXGI_FORMAT Format,
- __in unsigned Offset)
+ ID3D11Buffer *pIndexBuffer,
+ DXGI_FORMAT Format,
+ unsigned Offset)
{
SYNCHRONIZED;
if(index_buffer.p != pIndexBuffer || index_format != Format || index_offset != Offset)
}
virtual void STDMETHODCALLTYPE IAGetIndexBuffer(
- __out_opt ID3D11Buffer **pIndexBuffer,
- __out_opt DXGI_FORMAT *Format,
- __out_opt unsigned *Offset)
+ ID3D11Buffer **pIndexBuffer,
+ DXGI_FORMAT *Format,
+ unsigned *Offset)
{
SYNCHRONIZED;
if(pIndexBuffer)
}
virtual void STDMETHODCALLTYPE IASetPrimitiveTopology(
- __in D3D11_PRIMITIVE_TOPOLOGY Topology)
+ D3D11_PRIMITIVE_TOPOLOGY Topology)
{
SYNCHRONIZED;
if(primitive_topology != Topology)
}
virtual void STDMETHODCALLTYPE IAGetPrimitiveTopology(
- __out D3D11_PRIMITIVE_TOPOLOGY *pTopology)
+ D3D11_PRIMITIVE_TOPOLOGY *pTopology)
{
SYNCHRONIZED;
*pTopology = primitive_topology;
}
virtual void STDMETHODCALLTYPE DrawIndexed(
- __in unsigned IndexCount,
- __in unsigned StartIndexLocation,
- __in int BaseVertexLocation)
+ unsigned IndexCount,
+ unsigned StartIndexLocation,
+ int BaseVertexLocation)
{
SYNCHRONIZED;
if(update_flags)
}
virtual void STDMETHODCALLTYPE Draw(
- __in unsigned VertexCount,
- __in unsigned StartVertexLocation)
+ unsigned VertexCount,
+ unsigned StartVertexLocation)
{
SYNCHRONIZED;
if(update_flags)
}
virtual void STDMETHODCALLTYPE DrawIndexedInstanced(
- __in unsigned IndexCountPerInstance,
- __in unsigned InstanceCount,
- __in unsigned StartIndexLocation,
- __in int BaseVertexLocation,
- __in unsigned StartInstanceLocation)
+ unsigned IndexCountPerInstance,
+ unsigned InstanceCount,
+ unsigned StartIndexLocation,
+ int BaseVertexLocation,
+ unsigned StartInstanceLocation)
{
SYNCHRONIZED;
if(update_flags)
}
virtual void STDMETHODCALLTYPE DrawInstanced(
- __in unsigned VertexCountPerInstance,
- __in unsigned InstanceCount,
- __in unsigned StartVertexLocation,
- __in unsigned StartInstanceLocation)
+ unsigned VertexCountPerInstance,
+ unsigned InstanceCount,
+ unsigned StartVertexLocation,
+ unsigned StartInstanceLocation)
{
SYNCHRONIZED;
if(update_flags)
}
virtual void STDMETHODCALLTYPE DrawIndexedInstancedIndirect(
- __in ID3D11Buffer *pBufferForArgs,
- __in unsigned AlignedByteOffsetForArgs)
+ ID3D11Buffer *pBufferForArgs,
+ unsigned AlignedByteOffsetForArgs)
{
SYNCHRONIZED;
if(update_flags)
}
virtual void STDMETHODCALLTYPE DrawInstancedIndirect(
- __in ID3D11Buffer *pBufferForArgs,
- __in unsigned AlignedByteOffsetForArgs)
+ ID3D11Buffer *pBufferForArgs,
+ unsigned AlignedByteOffsetForArgs)
{
SYNCHRONIZED;
if(update_flags)
#if API >= 11
virtual void STDMETHODCALLTYPE Dispatch(
- __in unsigned ThreadGroupCountX,
- __in unsigned ThreadGroupCountY,
- __in unsigned ThreadGroupCountZ)
+ unsigned ThreadGroupCountX,
+ unsigned ThreadGroupCountY,
+ unsigned ThreadGroupCountZ)
{
// uncomment this when this is implemented
// SYNCHRONIZED;
}
virtual void STDMETHODCALLTYPE DispatchIndirect(
- __in ID3D11Buffer *pBufferForArgs,
- __in unsigned AlignedByteOffsetForArgs)
+ ID3D11Buffer *pBufferForArgs,
+ unsigned AlignedByteOffsetForArgs)
{
// uncomment this when this is implemented
// SYNCHRONIZED;
}
virtual void STDMETHODCALLTYPE RSSetState(
- __in_opt ID3D11RasterizerState *pRasterizerState)
+ ID3D11RasterizerState *pRasterizerState)
{
SYNCHRONIZED;
if(pRasterizerState != rasterizer_state.p)
}
virtual void STDMETHODCALLTYPE RSGetState(
- __out ID3D11RasterizerState **ppRasterizerState)
+ ID3D11RasterizerState **ppRasterizerState)
{
SYNCHRONIZED;
*ppRasterizerState = rasterizer_state.ref();
}
virtual void STDMETHODCALLTYPE RSSetViewports(
- __in_range(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) unsigned NumViewports,
- __in_ecount_opt(NumViewports) const D3D11_VIEWPORT *pViewports)
+ unsigned NumViewports,
+ const D3D11_VIEWPORT *pViewports)
{
SYNCHRONIZED;
if(NumViewports)
}
virtual void STDMETHODCALLTYPE RSGetViewports(
- __inout_range(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) unsigned *pNumViewports,
- __out_ecount_opt(*pNumViewports) D3D11_VIEWPORT *pViewports)
+ unsigned *pNumViewports,
+ D3D11_VIEWPORT *pViewports)
{
SYNCHRONIZED;
if(pViewports)
}
virtual void STDMETHODCALLTYPE RSSetScissorRects(
- __in_range(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) unsigned NumRects,
- __in_ecount_opt(NumRects) const D3D11_RECT *pRects)
+ unsigned NumRects,
+ const D3D11_RECT *pRects)
{
SYNCHRONIZED;
if(NumRects)
}
virtual void STDMETHODCALLTYPE RSGetScissorRects(
- __inout_range(0, D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE) unsigned *pNumRects,
- __out_ecount_opt(*pNumRects) D3D11_RECT *pRects)
+ unsigned *pNumRects,
+ D3D11_RECT *pRects)
{
SYNCHRONIZED;
if(pRects)
}
virtual void STDMETHODCALLTYPE OMSetBlendState(
- __in_opt ID3D11BlendState *pBlendState,
- __in_opt const float BlendFactor[ 4 ],
- __in unsigned SampleMask)
+ ID3D11BlendState *pBlendState,
+ const float BlendFactor[ 4 ],
+ unsigned SampleMask)
{
SYNCHRONIZED;
float white[4] = {1.0f, 1.0f, 1.0f, 1.0f};
}
virtual void STDMETHODCALLTYPE OMGetBlendState(
- __out_opt ID3D11BlendState **ppBlendState,
- __out_opt float BlendFactor[ 4 ],
- __out_opt unsigned *pSampleMask)
+ ID3D11BlendState **ppBlendState,
+ float BlendFactor[ 4 ],
+ unsigned *pSampleMask)
{
SYNCHRONIZED;
if(ppBlendState)
}
virtual void STDMETHODCALLTYPE OMSetDepthStencilState(
- __in_opt ID3D11DepthStencilState *pDepthStencilState,
- __in unsigned StencilRef)
+ ID3D11DepthStencilState *pDepthStencilState,
+ unsigned StencilRef)
{
SYNCHRONIZED;
if(pDepthStencilState != depth_stencil_state.p)
}
virtual void STDMETHODCALLTYPE OMGetDepthStencilState(
- __out_opt ID3D11DepthStencilState **ppDepthStencilState,
- __out_opt unsigned *pStencilRef)
+ ID3D11DepthStencilState **ppDepthStencilState,
+ unsigned *pStencilRef)
{
SYNCHRONIZED;
if(*ppDepthStencilState)
*/
virtual void STDMETHODCALLTYPE OMSetRenderTargets(
- __in_range(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) unsigned NumViews,
- __in_ecount_opt(NumViews) ID3D11RenderTargetView *const *ppRenderTargetViews,
- __in_opt ID3D11DepthStencilView *pDepthStencilView)
+ unsigned NumViews,
+ ID3D11RenderTargetView *const *ppRenderTargetViews,
+ ID3D11DepthStencilView *pDepthStencilView)
{
SYNCHRONIZED;
if(!ppRenderTargetViews)
}
virtual void STDMETHODCALLTYPE OMGetRenderTargets(
- __in_range(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) unsigned NumViews,
- __out_ecount_opt(NumViews) ID3D11RenderTargetView **ppRenderTargetViews,
- __out_opt ID3D11DepthStencilView **ppDepthStencilView)
+ unsigned NumViews,
+ ID3D11RenderTargetView **ppRenderTargetViews,
+ ID3D11DepthStencilView **ppDepthStencilView)
{
SYNCHRONIZED;
if(ppRenderTargetViews)
#if API >= 11
/* TODO: what is this supposed to do _exactly_? are we doing the right thing? */
virtual void STDMETHODCALLTYPE OMSetRenderTargetsAndUnorderedAccessViews(
- __in unsigned NumRTVs,
- __in_ecount_opt(NumRTVs) ID3D11RenderTargetView *const *ppRenderTargetViews,
- __in_opt ID3D11DepthStencilView *pDepthStencilView,
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - 1) unsigned UAVStartSlot,
- __in unsigned NumUAVs,
- __in_ecount_opt(NumUAVs) ID3D11UnorderedAccessView *const *ppUnorderedAccessViews,
- __in_ecount_opt(NumUAVs) const unsigned *pUAVInitialCounts)
+ unsigned NumRTVs,
+ ID3D11RenderTargetView *const *ppRenderTargetViews,
+ ID3D11DepthStencilView *pDepthStencilView,
+ unsigned UAVStartSlot,
+ unsigned NumUAVs,
+ ID3D11UnorderedAccessView *const *ppUnorderedAccessViews,
+ const unsigned *pUAVInitialCounts)
{
SYNCHRONIZED;
if(NumRTVs != D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL)
}
virtual void STDMETHODCALLTYPE OMGetRenderTargetsAndUnorderedAccessViews(
- __in_range(0, D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT) unsigned NumRTVs,
- __out_ecount_opt(NumRTVs) ID3D11RenderTargetView **ppRenderTargetViews,
- __out_opt ID3D11DepthStencilView **ppDepthStencilView,
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - 1) unsigned UAVStartSlot,
- __in_range(0, D3D11_PS_CS_UAV_REGISTER_COUNT - UAVStartSlot) unsigned NumUAVs,
- __out_ecount_opt(NumUAVs) ID3D11UnorderedAccessView **ppUnorderedAccessViews)
+ unsigned NumRTVs,
+ ID3D11RenderTargetView **ppRenderTargetViews,
+ ID3D11DepthStencilView **ppDepthStencilView,
+ unsigned UAVStartSlot,
+ unsigned NumUAVs,
+ ID3D11UnorderedAccessView **ppUnorderedAccessViews)
{
SYNCHRONIZED;
if(ppRenderTargetViews)
#endif
virtual void STDMETHODCALLTYPE SOSetTargets(
- __in_range(0, D3D11_SO_BUFFER_SLOT_COUNT) unsigned NumBuffers,
- __in_ecount_opt(NumBuffers) ID3D11Buffer *const *ppSOTargets,
- __in_ecount_opt(NumBuffers) const unsigned *pOffsets)
+ unsigned NumBuffers,
+ ID3D11Buffer *const *ppSOTargets,
+ const unsigned *pOffsets)
{
SYNCHRONIZED;
unsigned i;
}
virtual void STDMETHODCALLTYPE SOGetTargets(
- __in_range(0, D3D11_SO_BUFFER_SLOT_COUNT) unsigned NumBuffers,
- __out_ecount(NumBuffers) ID3D11Buffer **ppSOTargets
+ unsigned NumBuffers,
+ ID3D11Buffer **ppSOTargets
#if API < 11
- , __out_ecount(NumBuffers) UINT *pOffsets
+ , UINT *pOffsets
#endif
)
{
}
virtual void STDMETHODCALLTYPE Begin(
- __in ID3D11Asynchronous *pAsync)
+ ID3D11Asynchronous *pAsync)
{
SYNCHRONIZED;
if(caps.queries)
}
virtual void STDMETHODCALLTYPE End(
- __in ID3D11Asynchronous *pAsync)
+ ID3D11Asynchronous *pAsync)
{
SYNCHRONIZED;
if(caps.queries)
}
virtual HRESULT STDMETHODCALLTYPE GetData(
- __in ID3D11Asynchronous *pAsync,
- __out_bcount_opt(DataSize) void *pData,
- __in unsigned DataSize,
- __in unsigned GetDataFlags)
+ ID3D11Asynchronous *pAsync,
+ void *pData,
+ unsigned DataSize,
+ unsigned GetDataFlags)
{
SYNCHRONIZED;
if(!caps.queries)
}
virtual void STDMETHODCALLTYPE SetPredication(
- __in_opt ID3D11Predicate *pPredicate,
- __in BOOL PredicateValue)
+ ID3D11Predicate *pPredicate,
+ BOOL PredicateValue)
{
SYNCHRONIZED;
if(render_predicate.p != pPredicate || render_predicate_value != PredicateValue)
}
virtual void STDMETHODCALLTYPE GetPredication(
- __out_opt ID3D11Predicate **ppPredicate,
- __out_opt BOOL *pPredicateValue)
+ ID3D11Predicate **ppPredicate,
+ BOOL *pPredicateValue)
{
SYNCHRONIZED;
if(ppPredicate)
}
virtual HRESULT STDMETHODCALLTYPE Map(
- __in ID3D11Resource *pResource,
- __in unsigned Subresource,
- __in D3D11_MAP MapType,
- __in unsigned MapFlags,
- __out D3D11_MAPPED_SUBRESOURCE *pMappedResource)
+ ID3D11Resource *pResource,
+ unsigned Subresource,
+ D3D11_MAP MapType,
+ unsigned MapFlags,
+ D3D11_MAPPED_SUBRESOURCE *pMappedResource)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource;
}
virtual void STDMETHODCALLTYPE Unmap(
- __in ID3D11Resource *pResource,
- __in unsigned Subresource)
+ ID3D11Resource *pResource,
+ unsigned Subresource)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource;
}
virtual void STDMETHODCALLTYPE CopySubresourceRegion(
- __in ID3D11Resource *pDstResource,
- __in unsigned DstSubresource,
- __in unsigned DstX,
- __in unsigned DstY,
- __in unsigned DstZ,
- __in ID3D11Resource *pSrcResource,
- __in unsigned SrcSubresource,
- __in_opt const D3D11_BOX *pSrcBox)
+ ID3D11Resource *pDstResource,
+ unsigned DstSubresource,
+ unsigned DstX,
+ unsigned DstY,
+ unsigned DstZ,
+ ID3D11Resource *pSrcResource,
+ unsigned SrcSubresource,
+ const D3D11_BOX *pSrcBox)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource;
}
virtual void STDMETHODCALLTYPE CopyResource(
- __in ID3D11Resource *pDstResource,
- __in ID3D11Resource *pSrcResource)
+ ID3D11Resource *pDstResource,
+ ID3D11Resource *pSrcResource)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource;
}
virtual void STDMETHODCALLTYPE UpdateSubresource(
- __in ID3D11Resource *pDstResource,
- __in unsigned DstSubresource,
- __in_opt const D3D11_BOX *pDstBox,
- __in const void *pSrcData,
- __in unsigned SrcRowPitch,
- __in unsigned SrcDepthPitch)
+ ID3D11Resource *pDstResource,
+ unsigned DstSubresource,
+ const D3D11_BOX *pDstBox,
+ const void *pSrcData,
+ unsigned SrcRowPitch,
+ unsigned SrcDepthPitch)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource;
#if API >= 11
virtual void STDMETHODCALLTYPE CopyStructureCount(
- __in ID3D11Buffer *pDstBuffer,
- __in unsigned DstAlignedByteOffset,
- __in ID3D11UnorderedAccessView *pSrcView)
+ ID3D11Buffer *pDstBuffer,
+ unsigned DstAlignedByteOffset,
+ ID3D11UnorderedAccessView *pSrcView)
{
SYNCHRONIZED;
}
#endif
virtual void STDMETHODCALLTYPE ClearRenderTargetView(
- __in ID3D11RenderTargetView *pRenderTargetView,
- __in const float ColorRGBA[4])
+ ID3D11RenderTargetView *pRenderTargetView,
+ const float ColorRGBA[4])
{
SYNCHRONIZED;
GalliumD3D11RenderTargetView* view = ((GalliumD3D11RenderTargetView*)pRenderTargetView);
}
virtual void STDMETHODCALLTYPE ClearDepthStencilView(
- __in ID3D11DepthStencilView *pDepthStencilView,
- __in unsigned ClearFlags,
- __in float Depth,
- __in UINT8 Stencil)
+ ID3D11DepthStencilView *pDepthStencilView,
+ unsigned ClearFlags,
+ float Depth,
+ UINT8 Stencil)
{
SYNCHRONIZED;
GalliumD3D11DepthStencilView* view = ((GalliumD3D11DepthStencilView*)pDepthStencilView);
#if API >= 11
virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewUint(
- __in ID3D11UnorderedAccessView *pUnorderedAccessView,
- __in const unsigned Values[ 4 ])
+ ID3D11UnorderedAccessView *pUnorderedAccessView,
+ const unsigned Values[ 4 ])
{
SYNCHRONIZED;
}
virtual void STDMETHODCALLTYPE ClearUnorderedAccessViewFloat(
- __in ID3D11UnorderedAccessView *pUnorderedAccessView,
- __in const float Values[ 4 ])
+ ID3D11UnorderedAccessView *pUnorderedAccessView,
+ const float Values[ 4 ])
{
SYNCHRONIZED;
}
}
virtual void STDMETHODCALLTYPE GenerateMips(
- __in ID3D11ShaderResourceView *pShaderResourceView)
+ ID3D11ShaderResourceView *pShaderResourceView)
{
SYNCHRONIZED;
#if API >= 11
/* TODO: hack SRVs or sampler states to handle this, or add to Gallium */
virtual void STDMETHODCALLTYPE SetResourceMinLOD(
- __in ID3D11Resource *pResource,
+ ID3D11Resource *pResource,
float MinLOD)
{
SYNCHRONIZED;
}
virtual float STDMETHODCALLTYPE GetResourceMinLOD(
- __in ID3D11Resource *pResource)
+ ID3D11Resource *pResource)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* resource = (GalliumD3D11Resource<>*)pResource;
#endif
virtual void STDMETHODCALLTYPE ResolveSubresource(
- __in ID3D11Resource *pDstResource,
- __in unsigned DstSubresource,
- __in ID3D11Resource *pSrcResource,
- __in unsigned SrcSubresource,
- __in DXGI_FORMAT Format)
+ ID3D11Resource *pDstResource,
+ unsigned DstSubresource,
+ ID3D11Resource *pSrcResource,
+ unsigned SrcSubresource,
+ DXGI_FORMAT Format)
{
SYNCHRONIZED;
GalliumD3D11Resource<>* dst = (GalliumD3D11Resource<>*)pDstResource;
#if API >= 11
virtual void STDMETHODCALLTYPE ExecuteCommandList(
- __in ID3D11CommandList *pCommandList,
+ ID3D11CommandList *pCommandList,
BOOL RestoreContextState)
{
SYNCHRONIZED;
virtual HRESULT STDMETHODCALLTYPE FinishCommandList(
BOOL RestoreDeferredContextState,
- __out_opt ID3D11CommandList **ppCommandList)
+ ID3D11CommandList **ppCommandList)
{
SYNCHRONIZED;
return E_NOTIMPL;
#if API < 11
extern "C" HRESULT STDMETHODCALLTYPE D3D10CreateBlob(
- __in SIZE_T NumBytes,
- __out LPD3D10BLOB *ppBuffer
+ SIZE_T NumBytes,
+ LPD3D10BLOB *ppBuffer
);
HRESULT STDMETHODCALLTYPE D3D10CreateBlob(
- __in SIZE_T NumBytes,
- __out LPD3D10BLOB *ppBuffer
+ SIZE_T NumBytes,
+ LPD3D10BLOB *ppBuffer
)
{
void* data = malloc(NumBytes);
}
LPCSTR STDMETHODCALLTYPE D3D10GetPixelShaderProfile(
- __in ID3D10Device *pDevice
+ ID3D10Device *pDevice
)
{
return "ps_4_0";
}
LPCSTR STDMETHODCALLTYPE D3D10GetVertexShaderProfile(
- __in ID3D10Device *pDevice
+ ID3D10Device *pDevice
)
{
return "vs_4_0";
}
LPCSTR STDMETHODCALLTYPE D3D10GetGeometryShaderProfile(
- __in ID3D10Device *pDevice
+ ID3D10Device *pDevice
)
{
return "gs_4_0";
}
HRESULT D3D10GetInputSignatureBlob(
- __in const void *pShaderBytecode,
- __in SIZE_T BytecodeLength,
- __out ID3D10Blob **ppSignatureBlob
+ const void *pShaderBytecode,
+ SIZE_T BytecodeLength,
+ ID3D10Blob **ppSignatureBlob
)
{
dxbc_chunk_signature* sig = dxbc_find_signature(pShaderBytecode, BytecodeLength, false);
}
HRESULT D3D10GetOutputSignatureBlob(
- __in const void *pShaderBytecode,
- __in SIZE_T BytecodeLength,
- __out ID3D10Blob **ppSignatureBlob
+ const void *pShaderBytecode,
+ SIZE_T BytecodeLength,
+ ID3D10Blob **ppSignatureBlob
)
{
dxbc_chunk_signature* sig = dxbc_find_signature(pShaderBytecode, BytecodeLength, true);
}
HRESULT D3D10GetInputAndOutputSignatureBlob(
- __in const void *pShaderBytecode,
- __in SIZE_T BytecodeLength,
- __out ID3D10Blob **ppSignatureBlob
+ const void *pShaderBytecode,
+ SIZE_T BytecodeLength,
+ ID3D10Blob **ppSignatureBlob
)
{
dxbc_chunk_signature* sigs[2];
}
virtual void STDMETHODCALLTYPE GetDevice(
- __out ID3D11Device **ppDevice
+ ID3D11Device **ppDevice
)
{
device->AddRef();
unsigned eviction_priority;
virtual void STDMETHODCALLTYPE SetEvictionPriority(
- __in unsigned EvictionPriority)
+ unsigned EvictionPriority)
{
eviction_priority = EvictionPriority;
}
struct GalliumDXGIResource : public IDXGIResource
{
virtual HRESULT STDMETHODCALLTYPE SetEvictionPriority(
- __in unsigned EvictionPriority)
+ unsigned EvictionPriority)
{
static_cast<Real*>(this)->eviction_priority = EvictionPriority;
return S_OK;
}
virtual HRESULT STDMETHODCALLTYPE GetDevice(
- __in REFIID riid,
- __out void **ppParent)
+ REFIID riid,
+ void **ppParent)
{
if(!static_cast<Real*>(this)->device)
return E_NOINTERFACE;
}
virtual HRESULT STDMETHODCALLTYPE GetParent(
- __in REFIID riid,
- __out void **ppParent)
+ REFIID riid,
+ void **ppParent)
{
if(!static_cast<Real*>(this)->device)
return E_NOINTERFACE;
}
virtual HRESULT STDMETHODCALLTYPE GetUsage(
- __out DXGI_USAGE *pUsage
+ DXGI_USAGE *pUsage
)
{
*pUsage = this->dxgi_usage;
: GalliumD3D11Resource<Base>(device, resource, dxgi_usage), desc(desc)
{}
virtual void STDMETHODCALLTYPE GetType(
- __out D3D11_RESOURCE_DIMENSION *pResourceDimension)
+ D3D11_RESOURCE_DIMENSION *pResourceDimension)
{
*pResourceDimension = Dim;
}
}
virtual HRESULT STDMETHODCALLTYPE Map(
- __in D3D10_MAP MapType,
- __in unsigned MapFlags,
- __out void **ppData)
+ D3D10_MAP MapType,
+ unsigned MapFlags,
+ void **ppData)
{
D3D10_MAPPED_SUBRESOURCE msr;
HRESULT hr = device->Map(this, 0, MapType, MapFlags, &msr);
{}
virtual HRESULT STDMETHODCALLTYPE Map(
- __in unsigned Subresource,
- __in D3D10_MAP MapType,
- __in unsigned MapFlags,
- __out void **ppData)
+ unsigned Subresource,
+ D3D10_MAP MapType,
+ unsigned MapFlags,
+ void **ppData)
{
D3D10_MAPPED_SUBRESOURCE msr;
HRESULT hr = device->Map(this, Subresource, MapType, MapFlags, &msr);
}
virtual void STDMETHODCALLTYPE Unmap(
- __in unsigned Subresource
+ unsigned Subresource
)
{
device->Unmap(this, Subresource);
{}
virtual HRESULT STDMETHODCALLTYPE Map(
- __in unsigned Subresource,
- __in D3D10_MAP MapType,
- __in unsigned MapFlags,
- __out D3D10_MAPPED_TEXTURE2D *pMappedTex2D)
+ unsigned Subresource,
+ D3D10_MAP MapType,
+ unsigned MapFlags,
+ D3D10_MAPPED_TEXTURE2D *pMappedTex2D)
{
D3D10_MAPPED_SUBRESOURCE msr;
HRESULT hr = device->Map(this, Subresource, MapType, MapFlags, &msr);
}
virtual void STDMETHODCALLTYPE Unmap(
- __in unsigned Subresource
+ unsigned Subresource
)
{
device->Unmap(this, Subresource);
{}
virtual HRESULT STDMETHODCALLTYPE Map(
- __in unsigned Subresource,
- __in D3D10_MAP MapType,
- __in unsigned MapFlags,
- __out D3D10_MAPPED_TEXTURE3D *pMappedTex3D)
+ unsigned Subresource,
+ D3D10_MAP MapType,
+ unsigned MapFlags,
+ D3D10_MAPPED_TEXTURE3D *pMappedTex3D)
{
D3D10_MAPPED_SUBRESOURCE msr;
HRESULT hr = device->Map(this, Subresource, MapType, MapFlags, &msr);
}
virtual void STDMETHODCALLTYPE Unmap(
- __in unsigned Subresource
+ unsigned Subresource
)
{
device->Unmap(this, Subresource);
}
virtual HRESULT STDMETHODCALLTYPE GetDesc(
- __out DXGI_SURFACE_DESC *pDesc)
+ DXGI_SURFACE_DESC *pDesc)
{
pDesc->Format = this->desc.Format;
pDesc->Width = this->desc.Width;
}
virtual HRESULT STDMETHODCALLTYPE GetParent(
- __in REFIID riid,
- __out void **ppParent)
+ REFIID riid,
+ void **ppParent)
{
if(!device)
return E_NOINTERFACE;
/* TODO: somehow implement these */
virtual HRESULT STDMETHODCALLTYPE GetDC(
BOOL Discard,
- __out HDC *phdc)
+ HDC *phdc)
{
*phdc = 0;
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE ReleaseDC(
- __in_opt RECT *pDirtyRect)
+ RECT *pDirtyRect)
{
return E_NOTIMPL;
}
virtual HRESULT STDMETHODCALLTYPE Map(
- __out DXGI_MAPPED_RECT *pLockedRect,
+ DXGI_MAPPED_RECT *pLockedRect,
unsigned MapFlags)
{
D3D11_MAP d3d_map;
}
virtual HRESULT STDMETHODCALLTYPE GetDevice(
- __in REFIID riid,
- __out void **ppParent)
+ REFIID riid,
+ void **ppParent)
{
if(!device)
return E_NOINTERFACE;
}
virtual HRESULT STDMETHODCALLTYPE GetData(
- __out_bcount(DataSize) void *pData,
- __in unsigned DataSize,
- __in unsigned GetDataFlags)
+ void *pData,
+ unsigned DataSize,
+ unsigned GetDataFlags)
{
return this->device->GetData(this, pData, DataSize, GetDataFlags);
}
{}
virtual void STDMETHODCALLTYPE GetDesc(
- __out D3D11_QUERY_DESC *pDesc)
+ D3D11_QUERY_DESC *pDesc)
{
*pDesc = desc;
}
{}
virtual void STDMETHODCALLTYPE GetDesc(
- __out D3D11_COUNTER_DESC *pDesc)
+ D3D11_COUNTER_DESC *pDesc)
{
*pDesc = desc;
}
#if API >= 11
virtual void STDMETHODCALLTYPE GetImmediateContext(
- __out ID3D11DeviceContext **ppImmediateContext)
+ ID3D11DeviceContext **ppImmediateContext)
{
immediate_context->AddRef();
*ppImmediateContext = immediate_context;
}
virtual HRESULT STDMETHODCALLTYPE CheckCounter(
- __in const D3D11_COUNTER_DESC *pDesc,
- __out D3D11_COUNTER_TYPE *pType,
- __out unsigned *pActiveCounters,
- __out_ecount_opt(*pNameLength) LPSTR szName,
- __inout_opt unsigned *pNameLength,
- __out_ecount_opt(*pUnitsLength) LPSTR szUnits,
- __inout_opt unsigned *pUnitsLength,
- __out_ecount_opt(*pDescriptionLength) LPSTR szDescription,
- __inout_opt unsigned *pDescriptionLength)
+ const D3D11_COUNTER_DESC *pDesc,
+ D3D11_COUNTER_TYPE *pType,
+ unsigned *pActiveCounters,
+ LPSTR szName,
+ unsigned *pNameLength,
+ LPSTR szUnits,
+ unsigned *pUnitsLength,
+ LPSTR szDescription,
+ unsigned *pDescriptionLength)
{
return E_NOTIMPL;
}
virtual void STDMETHODCALLTYPE CheckCounterInfo(
- __out D3D11_COUNTER_INFO *pCounterInfo)
+ D3D11_COUNTER_INFO *pCounterInfo)
{
/* none supported at the moment */
pCounterInfo->LastDeviceDependentCounter = (D3D11_COUNTER)0;
#if API >= 11
virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport(
D3D11_FEATURE Feature,
- __out_bcount(FeatureSupportDataSize) void *pFeatureSupportData,
+ void *pFeatureSupportData,
unsigned FeatureSupportDataSize)
{
SYNCHRONIZED;
#if API >= 11
virtual HRESULT STDMETHODCALLTYPE CreateBlendState(
- __in const D3D11_BLEND_DESC *pBlendStateDesc,
- __out_opt ID3D11BlendState **ppBlendState
+ const D3D11_BLEND_DESC *pBlendStateDesc,
+ ID3D11BlendState **ppBlendState
)
#else
virtual HRESULT STDMETHODCALLTYPE CreateBlendState1(
- __in const D3D10_BLEND_DESC1 *pBlendStateDesc,
- __out_opt ID3D10BlendState1 **ppBlendState
+ const D3D10_BLEND_DESC1 *pBlendStateDesc,
+ ID3D10BlendState1 **ppBlendState
)
#endif
{
#if API < 11
virtual HRESULT STDMETHODCALLTYPE CreateBlendState(
- __in const D3D10_BLEND_DESC *pBlendStateDesc,
- __out_opt ID3D10BlendState **ppBlendState
+ const D3D10_BLEND_DESC *pBlendStateDesc,
+ ID3D10BlendState **ppBlendState
)
{
SYNCHRONIZED;
#endif
virtual HRESULT STDMETHODCALLTYPE CreateDepthStencilState(
- __in const D3D11_DEPTH_STENCIL_DESC *pDepthStencilStateDesc,
- __out_opt ID3D11DepthStencilState **ppDepthStencilState
+ const D3D11_DEPTH_STENCIL_DESC *pDepthStencilStateDesc,
+ ID3D11DepthStencilState **ppDepthStencilState
)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateRasterizerState(
- __in const D3D11_RASTERIZER_DESC *pRasterizerDesc,
- __out_opt ID3D11RasterizerState **ppRasterizerState)
+ const D3D11_RASTERIZER_DESC *pRasterizerDesc,
+ ID3D11RasterizerState **ppRasterizerState)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateSamplerState(
- __in const D3D11_SAMPLER_DESC *pSamplerDesc,
- __out_opt ID3D11SamplerState **ppSamplerState)
+ const D3D11_SAMPLER_DESC *pSamplerDesc,
+ ID3D11SamplerState **ppSamplerState)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateInputLayout(
- __in_ecount(NumElements) const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs,
- __in_range(0, D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT) unsigned NumElements,
- __in const void *pShaderBytecodeWithInputSignature,
- __in SIZE_T BytecodeLength,
- __out_opt ID3D11InputLayout **ppInputLayout)
+ const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs,
+ unsigned NumElements,
+ const void *pShaderBytecodeWithInputSignature,
+ SIZE_T BytecodeLength,
+ ID3D11InputLayout **ppInputLayout)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateTexture1D(
- __in const D3D11_TEXTURE1D_DESC *pDesc,
- __in_xcount_opt(pDesc->MipLevels * pDesc->ArraySize) const D3D11_SUBRESOURCE_DATA *pInitialData,
- __out_opt ID3D11Texture1D **ppTexture1D)
+ const D3D11_TEXTURE1D_DESC *pDesc,
+ const D3D11_SUBRESOURCE_DATA *pInitialData,
+ ID3D11Texture1D **ppTexture1D)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateTexture2D(
- __in const D3D11_TEXTURE2D_DESC *pDesc,
- __in_xcount_opt(pDesc->MipLevels * pDesc->ArraySize) const D3D11_SUBRESOURCE_DATA *pInitialData,
- __out_opt ID3D11Texture2D **ppTexture2D)
+ const D3D11_TEXTURE2D_DESC *pDesc,
+ const D3D11_SUBRESOURCE_DATA *pInitialData,
+ ID3D11Texture2D **ppTexture2D)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateTexture3D(
- __in const D3D11_TEXTURE3D_DESC *pDesc,
- __in_xcount_opt(pDesc->MipLevels) const D3D11_SUBRESOURCE_DATA *pInitialData,
- __out_opt ID3D11Texture3D **ppTexture3D)
+ const D3D11_TEXTURE3D_DESC *pDesc,
+ const D3D11_SUBRESOURCE_DATA *pInitialData,
+ ID3D11Texture3D **ppTexture3D)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateBuffer(
- __in const D3D11_BUFFER_DESC *pDesc,
- __in_opt const D3D11_SUBRESOURCE_DATA *pInitialData,
- __out_opt ID3D11Buffer **ppBuffer)
+ const D3D11_BUFFER_DESC *pDesc,
+ const D3D11_SUBRESOURCE_DATA *pInitialData,
+ ID3D11Buffer **ppBuffer)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE OpenGalliumResource(
- __in struct pipe_resource* resource,
- __out IUnknown** dxgi_resource)
+ struct pipe_resource* resource,
+ IUnknown** dxgi_resource)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateSurface(
- __in const DXGI_SURFACE_DESC *pDesc,
+ const DXGI_SURFACE_DESC *pDesc,
unsigned NumSurfaces,
DXGI_USAGE Usage,
- __in_opt const DXGI_SHARED_RESOURCE *pSharedResource,
- __out IDXGISurface **ppSurface)
+ const DXGI_SHARED_RESOURCE *pSharedResource,
+ IDXGISurface **ppSurface)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateShaderResourceView(
- __in ID3D11Resource *pResource,
- __in_opt const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc,
- __out_opt ID3D11ShaderResourceView **ppSRView)
+ ID3D11Resource *pResource,
+ const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc,
+ ID3D11ShaderResourceView **ppSRView)
{
#if API >= 11
D3D11_SHADER_RESOURCE_VIEW_DESC def_desc;
}
virtual HRESULT STDMETHODCALLTYPE CreateShaderResourceView1(
- __in ID3D11Resource *pResource,
- __in_opt const D3D10_SHADER_RESOURCE_VIEW_DESC1 *pDesc,
- __out_opt ID3D10ShaderResourceView1 **ppSRView)
+ ID3D11Resource *pResource,
+ const D3D10_SHADER_RESOURCE_VIEW_DESC1 *pDesc,
+ ID3D10ShaderResourceView1 **ppSRView)
{
D3D10_SHADER_RESOURCE_VIEW_DESC1 def_desc;
#endif
#if API >= 11
virtual HRESULT STDMETHODCALLTYPE CreateUnorderedAccessView(
- __in ID3D11Resource *pResource,
- __in_opt const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc,
- __out_opt ID3D11UnorderedAccessView **ppUAView)
+ ID3D11Resource *pResource,
+ const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+ ID3D11UnorderedAccessView **ppUAView)
{
SYNCHRONIZED;
#endif
virtual HRESULT STDMETHODCALLTYPE CreateRenderTargetView(
- __in ID3D11Resource *pResource,
- __in_opt const D3D11_RENDER_TARGET_VIEW_DESC *pDesc,
- __out_opt ID3D11RenderTargetView **ppRTView)
+ ID3D11Resource *pResource,
+ const D3D11_RENDER_TARGET_VIEW_DESC *pDesc,
+ ID3D11RenderTargetView **ppRTView)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreateDepthStencilView(
- __in ID3D11Resource *pResource,
- __in_opt const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc,
- __out_opt ID3D11DepthStencilView **ppDepthStencilView)
+ ID3D11Resource *pResource,
+ const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc,
+ ID3D11DepthStencilView **ppDepthStencilView)
{
SYNCHRONIZED;
GalliumD3D11Shader<>* create_stage_shader(unsigned type, const void *pShaderBytecode, SIZE_T BytecodeLength
#if API >= 11
- , __in_opt ID3D11ClassLinkage *pClassLinkage
+ , ID3D11ClassLinkage *pClassLinkage
#endif
)
{
#if API >= 11
#define CREATE_SHADER_ARGS \
- __in const void *pShaderBytecode, \
- __in SIZE_T BytecodeLength, \
- __in_opt ID3D11ClassLinkage *pClassLinkage
+ const void *pShaderBytecode, \
+ SIZE_T BytecodeLength, \
+ ID3D11ClassLinkage *pClassLinkage
#define PASS_SHADER_ARGS pShaderBytecode, BytecodeLength, pClassLinkage
#else
#define CREATE_SHADER_ARGS \
- __in const void *pShaderBytecode, \
- __in SIZE_T BytecodeLength
+ const void *pShaderBytecode, \
+ SIZE_T BytecodeLength
#define PASS_SHADER_ARGS pShaderBytecode, BytecodeLength
#endif
#define IMPLEMENT_CREATE_SHADER(Stage, GALLIUM) \
virtual HRESULT STDMETHODCALLTYPE Create##Stage##Shader( \
CREATE_SHADER_ARGS, \
- __out_opt ID3D11##Stage##Shader **pp##Stage##Shader) \
+ ID3D11##Stage##Shader **pp##Stage##Shader) \
{ \
SYNCHRONIZED; \
GalliumD3D11##Stage##Shader* shader = (GalliumD3D11##Stage##Shader*)create_stage_shader(PIPE_SHADER_##GALLIUM, PASS_SHADER_ARGS); \
#define IMPLEMENT_NOTIMPL_CREATE_SHADER(Stage) \
virtual HRESULT STDMETHODCALLTYPE Create##Stage##Shader( \
CREATE_SHADER_ARGS, \
- __out_opt ID3D11##Stage##Shader **pp##Stage##Shader) \
+ ID3D11##Stage##Shader **pp##Stage##Shader) \
{ \
return E_NOTIMPL; \
}
#endif
virtual HRESULT STDMETHODCALLTYPE CreateGeometryShaderWithStreamOutput(
- __in const void *pShaderBytecode,
- __in SIZE_T BytecodeLength,
- __in_ecount_opt(NumEntries) const D3D11_SO_DECLARATION_ENTRY *pSODeclaration,
- __in_range(0, D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT) unsigned NumEntries,
+ const void *pShaderBytecode,
+ SIZE_T BytecodeLength,
+ const D3D11_SO_DECLARATION_ENTRY *pSODeclaration,
+ unsigned NumEntries,
#if API >= 11
- __in_ecount_opt(NumStrides) const unsigned *pBufferStrides,
- __in_range(0, D3D11_SO_BUFFER_SLOT_COUNT) unsigned NumStrides,
- __in unsigned RasterizedStream,
- __in_opt ID3D11ClassLinkage *pClassLinkage,
+ const unsigned *pBufferStrides,
+ unsigned NumStrides,
+ unsigned RasterizedStream,
+ ID3D11ClassLinkage *pClassLinkage,
#else
- __in UINT OutputStreamStride,
+ UINT OutputStreamStride,
#endif
- __out_opt ID3D11GeometryShader **ppGeometryShader)
+ ID3D11GeometryShader **ppGeometryShader)
{
SYNCHRONIZED;
#if API >= 11
virtual HRESULT STDMETHODCALLTYPE CreateClassLinkage(
- __out ID3D11ClassLinkage **ppLinkage)
+ ID3D11ClassLinkage **ppLinkage)
{
SYNCHRONIZED;
#endif
virtual HRESULT STDMETHODCALLTYPE CreateQuery(
- __in const D3D11_QUERY_DESC *pQueryDesc,
- __out_opt ID3D11Query **ppQuery)
+ const D3D11_QUERY_DESC *pQueryDesc,
+ ID3D11Query **ppQuery)
{
SYNCHRONIZED;
}
virtual HRESULT STDMETHODCALLTYPE CreatePredicate(
- __in const D3D11_QUERY_DESC *pPredicateDesc,
- __out_opt ID3D11Predicate **ppPredicate)
+ const D3D11_QUERY_DESC *pPredicateDesc,
+ ID3D11Predicate **ppPredicate)
{
SYNCHRONIZED;
virtual HRESULT STDMETHODCALLTYPE CreateCounter(
- __in const D3D11_COUNTER_DESC *pCounterDesc,
- __out_opt ID3D11Counter **ppCounter)
+ const D3D11_COUNTER_DESC *pCounterDesc,
+ ID3D11Counter **ppCounter)
{
SYNCHRONIZED;
#if API >= 11
virtual HRESULT STDMETHODCALLTYPE CreateDeferredContext(
unsigned ContextFlags,
- __out_opt ID3D11DeviceContext **ppDeferredContext)
+ ID3D11DeviceContext **ppDeferredContext)
{
SYNCHRONIZED;
#endif
virtual HRESULT STDMETHODCALLTYPE OpenSharedResource(
- __in HANDLE hResource,
- __in REFIID ReturnedInterface,
- __out_opt void **ppResource)
+ HANDLE hResource,
+ REFIID ReturnedInterface,
+ void **ppResource)
{
SYNCHRONIZED;
* Probably nothing uses these, assuming it has ever been implemented anywhere.
*/
void STDMETHODCALLTYPE SetTextFilterSize(
- __in UINT Width,
- __in UINT Height
+ UINT Width,
+ UINT Height
)
{}
virtual void STDMETHODCALLTYPE GetTextFilterSize(
- __in UINT *Width,
- __in UINT *Height
+ UINT *Width,
+ UINT *Height
)
{}
#endif
projects / mesa.git / commitdiff