bybrooklyn/WinDurango
1
0
Fork 0
mirror of https://codeberg.org/WinDurango/WinDurango.git synced 2026-04-18 02:23:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

D3D11.X init and definitions

Browse Source
This commit is contained in:
Rodrigo Todescatto
2026-02-06 19:21:42 -03:00
parent 08a6f17738
commit 903a847191
18 changed files with 8172 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11Device.h Normal file
View File

@@ -0,0 +1,179 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11DeviceX : public gfx::ID3D11DeviceX<ABI>
{
public:
ID3D11Device2 *m_pFunction;
D3D11DeviceX(ID3D11Device2* pDevice)
{
m_pFunction = pDevice;
InterlockedIncrement(&this->m_RefCount);
}
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11Device
//
HRESULT CreateBuffer(D3D11_BUFFER_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Buffer<ABI> **ppBuffer);
HRESULT CreateTexture1D(D3D11_TEXTURE1D_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Texture1D<ABI> **ppTexture1D);
HRESULT CreateTexture2D(D3D11_TEXTURE2D_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Texture2D<ABI> **ppTexture2D);
HRESULT CreateTexture3D(D3D11_TEXTURE3D_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Texture3D<ABI> **ppTexture3D);
HRESULT CreateShaderResourceView(gfx::ID3D11Resource<ABI> *pResource, D3D11_SHADER_RESOURCE_VIEW_DESC const *pDesc,
gfx::ID3D11ShaderResourceView<ABI> **ppSRV);
HRESULT CreateUnorderedAccessView(gfx::ID3D11Resource<ABI> *pResource,
D3D11_UNORDERED_ACCESS_VIEW_DESC const *pDesc,
gfx::ID3D11UnorderedAccessView<ABI> **ppUAV);
HRESULT CreateRenderTargetView(gfx::ID3D11Resource<ABI> *pResource, D3D11_RENDER_TARGET_VIEW_DESC const *pDesc,
gfx::ID3D11RenderTargetView<ABI> **ppRTV);
HRESULT CreateDepthStencilView(gfx::ID3D11Resource<ABI> *pResource, D3D11_DEPTH_STENCIL_VIEW_DESC const *pDesc,
gfx::ID3D11DepthStencilView<ABI> **ppDSV);
HRESULT CreateInputLayout(D3D11_INPUT_ELEMENT_DESC const *pDesc, uint32_t NumElements,
void const *pShaderBytecodeWithInputSignature, uint64_t BytecodeLength,
ID3D11InputLayout **ppInputLayout);
HRESULT CreateVertexShader(void const *pBytecode, uint64_t BytecodeLength, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11VertexShader<ABI> **ppVS);
HRESULT CreateGeometryShader(void const *pBytecode, uint64_t BytecodeLentgh, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11GeometryShader<ABI> **ppGS);
HRESULT CreateGeometryShaderWithStreamOutput(void const *pBytecode, uint64_t BytecodeLentgh,
D3D11_SO_DECLARATION_ENTRY const *pSODeclaration, uint32_t NumEntries,
uint32_t const *pStrides, uint32_t NumStides,
uint32_t RasterizedStream, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11GeometryShader<ABI> **ppGS);
HRESULT CreatePixelShader(void const *pBytecode, uint64_t BytecodeLentgh, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11PixelShader<ABI> **ppPS);
HRESULT CreateHullShader(void const *pBytecode, uint64_t BytecodeLentgh, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11HullShader<ABI> **ppHS);
HRESULT CreateDomainShader(void const *pBytecode, uint64_t BytecodeLentgh, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11DomainShader<ABI> **ppDS);
HRESULT CreateComputeShader(void const *pBytecode, uint64_t BytecodeLentgh, ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11ComputeShader<ABI> **ppCS);
HRESULT CreateClassLinkage(ID3D11ClassLinkage **ppClassLinkage);
HRESULT CreateBlendState(D3D11_BLEND_DESC const *pDesc, gfx::ID3D11BlendState<ABI> **ppBlendState);
HRESULT CreateDepthStencilState(D3D11_DEPTH_STENCIL_DESC const *pDesc,
gfx::ID3D11DepthStencilState<ABI> **ppDepthStencilState);
HRESULT CreateRasterizerState(D3D11_RASTERIZER_DESC const *pDesc,
gfx::ID3D11RasterizerState<ABI> **ppRasterizerState);
HRESULT CreateSamplerState(D3D11_SAMPLER_DESC const *pDesc, gfx::ID3D11SamplerState<ABI> **ppSamplerState);
HRESULT CreateQuery(D3D11_QUERY_DESC const *pDesc, ID3D11Query **ppQuery);
HRESULT CreatePredicate(D3D11_QUERY_DESC const *pDesc, ID3D11Predicate **ppPrediticate);
HRESULT CreateCounter(D3D11_COUNTER_DESC const *pDesc, ID3D11Counter **ppCounter);
HRESULT CreateDeferredContext(uint32_t Flags, gfx::ID3D11DeviceContext<ABI> **ppDeferredContext);
HRESULT OpenSharedResource(void *pResource, _GUID const &retInterface, void **ppResource);
HRESULT CheckFormatSupport(DXGI_FORMAT Format, uint32_t *pFormatSupport);
HRESULT CheckMultisampleQualityLevels(DXGI_FORMAT Format, uint32_t SampleCount, uint32_t *pNumQualityLevels);
void CheckCounterInfo(D3D11_COUNTER_INFO *pCounterInfo);
HRESULT CheckCounter(D3D11_COUNTER_DESC const *pDesc, D3D11_COUNTER_TYPE *pCounterType, uint32_t *pActiveCounters,
char *szName, uint32_t *pNameLength, char *szUnits, uint32_t *pUnitsLength,
char *szDescription, uint32_t *pDescriptionLength);
HRESULT CheckFeatureSupport(D3D11_FEATURE Feature, void *pFeatureSupportData, uint32_t FeatureSupportDataSize);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
D3D_FEATURE_LEVEL GetFeatureLevel();
uint32_t GetCreationFlags();
HRESULT GetDeviceRemovedReason();
void GetImmediateContext(gfx::ID3D11DeviceContext<ABI> **ppImmediateContext);
HRESULT SetExceptionMode(uint32_t ExceptionMode);
uint32_t GetExceptionMode();
//
// ID3D11Device1
//
void GetImmediateContext1(gfx::ID3D11DeviceContext1<ABI> **ppImmediateContext);
HRESULT CreateDeferredContext1(uint32_t Flags, gfx::ID3D11DeviceContext1<ABI> **ppDeferredContext1);
HRESULT CreateBlendState1(D3D11_BLEND_DESC1 const *pDesc, ID3D11BlendState1 **ppBlendState);
HRESULT CreateRasterizerState1(D3D11_RASTERIZER_DESC1 const *pDesc, ID3D11RasterizerState1 **ppRasterizerState);
HRESULT CreateDeviceContextState(uint32_t Flags, D3D_FEATURE_LEVEL const *pFeatureLevels, uint32_t FeatureLevels,
uint32_t SDKVersion, _GUID const &EmulatedInterface,
D3D_FEATURE_LEVEL *pChosenFeatureLevel, ID3DDeviceContextState **ppContextState);
HRESULT OpenSharedResource1(void *pResource, _GUID const &retInterface, void **ppResource);
HRESULT OpenSharedResourceByName(wchar_t const *pName, uint32_t dwDesiredAccess, _GUID const &retInterface,
void **ppResource);
//
// ID3D11Device2
//
void GetImmediateContext2(gfx::ID3D11DeviceContext2<ABI> **ppImmediateContext);
HRESULT CreateDeferredContext2(uint32_t Flags, gfx::ID3D11DeviceContext2<ABI> **ppDeferredContext);
void GetResourceTiling(gfx::ID3D11Resource<ABI> *pTiledResource, uint32_t *pNumTilesForEntireResource,
D3D11_PACKED_MIP_DESC *pPackedMipDesc, D3D11_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
uint32_t *pNumSubresourceTilings, uint32_t FirstSubresourceTilingToGet,
D3D11_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips);
HRESULT CheckMultisampleQualityLevels1(DXGI_FORMAT Format, uint32_t SampleCount, uint32_t Flags,
uint32_t *pNumQualityLevels);
//
// ID3D11DeviceX
//
void GetImmediateContextX(gfx::ID3D11DeviceContextX<ABI> **ppImmediateContextX);
HRESULT CreateCounterSet(gfx::D3D11X_COUNTER_SET_DESC const *pCounterSetDesc,
gfx::ID3D11CounterSetX **ppCounterSet);
HRESULT CreateCounterSample(gfx::ID3D11CounterSampleX **ppCounterSample);
HRESULT SetDriverHint(UINT Feature, UINT Value);
HRESULT CreateDmaEngineContext(gfx::D3D11_DMA_ENGINE_CONTEXT_DESC const *pDmaEngineContextDesc,
gfx::ID3D11DMAEngineContextX<ABI> **ppDmaDeviceContext);
BOOL IsFencePending(UINT64 Fence);
BOOL IsResourcePending(gfx::ID3D11Resource<ABI> *pResource);
HRESULT CreatePlacementBuffer(D3D11_BUFFER_DESC const *pDesc, void *pVirtualAddress,
gfx::ID3D11Buffer<ABI> **ppBuffer);
HRESULT CreatePlacementTexture1D(D3D11_TEXTURE1D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
void *pVirtualAddress, gfx::ID3D11Texture1D<ABI> **ppTexture1D);
HRESULT CreatePlacementTexture2D(D3D11_TEXTURE2D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
void *pVirtualAddress, gfx::ID3D11Texture2D<ABI> **ppTexture2D);
HRESULT CreatePlacementTexture3D(D3D11_TEXTURE3D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
void *pVirtualAddress, gfx::ID3D11Texture3D<ABI> **ppTexture3D);
void GetTimestamps(UINT64 *pGpuTimestamp, UINT64 *pCpuRdtscTimestamp);
HRESULT CreateComputeContextX(gfx::D3D11_COMPUTE_CONTEXT_DESC const *pComputeContextDesc,
gfx::ID3D11ComputeContextX **ppComputeContext);
HRESULT CreateSamplerStateX(gfx::D3D11X_SAMPLER_DESC const *pSamplerDesc,
gfx::ID3D11SamplerState<ABI> **ppSamplerState);
HRESULT CreateDeferredContextX(UINT Flags, gfx::ID3D11DeviceContextX<ABI> **ppDeferredContext);
void GarbageCollect(UINT Flags);
HRESULT CreateDepthStencilStateX(D3D11_DEPTH_STENCIL_DESC const *pDepthStencilStateDesc,
gfx::ID3D11DepthStencilState<ABI> **ppDepthStencilState);
HRESULT CreatePlacementRenderableTexture2D(D3D11_TEXTURE2D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
gfx::D3D11X_RENDERABLE_TEXTURE_ADDRESSES const *pAddresses,
gfx::ID3D11Texture2D<ABI> **ppTexture2D);
void GetDriverStatistics(UINT StructSize, gfx::D3D11X_DRIVER_STATISTICS *pStatistics);
HRESULT GetDescriptorSize(gfx::D3D11X_DESCRIPTOR_TYPE DescriptorType);
void ComposeShaderResourceView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_SHADER_RESOURCE_VIEW *pDescriptorSrv);
void ComposeUnorderedAccessView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_UNORDERED_ACCESS_VIEW *pDescriptorUav);
void ComposeConstantBufferView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_CONSTANT_BUFFER_VIEW *pDescriptorCb);
void ComposeVertexBufferView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_VERTEX_BUFFER_VIEW *pDescriptorVb);
void ComposeSamplerState(gfx::D3D11X_SAMPLER_STATE_DESC const *pSamplerDesc,
gfx::D3D11X_DESCRIPTOR_SAMPLER_STATE *pDescriptorSamplerState);
void PlaceSwapChainView(gfx::ID3D11Resource<ABI> *pSwapChainBuffer, gfx::ID3D11View<ABI> *pView);
void SetDebugFlags(UINT Flags);
uint32_t GetDebugFlags();
void SetHangCallbacks(gfx::D3D11XHANGBEGINCALLBACK pBeginCallback, gfx::D3D11XHANGPRINTCALLBACK pPrintCallback,
gfx::D3D11XHANGDUMPCALLBACK pDumpCallback);
void ReportGpuHang(UINT Flags);
HRESULT SetGpuMemoryPriority(UINT Priority);
void GetGpuHardwareConfiguration(gfx::D3D11X_GPU_HARDWARE_CONFIGURATION *pGpuHardwareConfiguration);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DeviceX<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

26
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11DeviceChild.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11DeviceChild : public gfx::ID3D11DeviceChild<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DeviceChild<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

425
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11DeviceContext.h Normal file
View File

@@ -0,0 +1,425 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11DeviceContextX : public gfx::ID3D11DeviceContextX<ABI>
{
public:
ID3D11DeviceContext2 *m_pFunction;
D3D11DeviceContextX(ID3D11DeviceContext2 *pContext)
{
m_pFunction = pContext;
InterlockedIncrement(&this->m_RefCount);
memcpy(&this->m_Function, *(void ***)this, sizeof(this->m_Function));
}
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11DeviceContext
//
void VSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers);
void PSSetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> *const *ppShaderResourceViews);
void PSSetShader(gfx::ID3D11PixelShader<ABI> *pPixelShader);
void PSSetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> *const *ppSamplers);
void VSSetShader(gfx::ID3D11VertexShader<ABI> *pVertexShader);
void DrawIndexed(UINT64 StartIndexLocationAndIndexCount, INT BaseVertexLocation);
void Draw(UINT VertexCount, UINT StartVertexLocation);
HRESULT Map(gfx::ID3D11Resource<ABI> *pResource, UINT Subresource, D3D11_MAP MapType, UINT MapFlags,
D3D11_MAPPED_SUBRESOURCE *pMappedResource);
void Unmap(gfx::ID3D11Resource<ABI> *pResource, UINT Subresource);
void PSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers);
void IASetInputLayout(ID3D11InputLayout *pInputLayout);
void IASetVertexBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppVertexBuffers,
UINT const *pStrides, UINT const *pOffsets);
void IASetIndexBuffer(UINT HardwareIndexFormat, gfx::ID3D11Buffer<ABI> *pIndexBuffer, UINT Offset);
void DrawIndexedInstanced(UINT StartIndexLocationAndIndexCountPerInstance,
UINT64 BaseVertexLocationAndStartInstanceLocation, UINT64 InstanceCount);
void DrawInstanced(UINT VertexCountPerInstance, UINT64 StartVertexLocationAndStartInstanceLocation,
UINT InstanceCount);
void GSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers);
void GSSetShader(gfx::ID3D11GeometryShader<ABI> *pShader);
void IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY PrimitiveTopology);
void VSSetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> *const *ppShaderResourceViews);
void VSSetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> *const *ppSamplers);
void Begin(ID3D11Asynchronous *pAsync);
void End(ID3D11Asynchronous *pAsync);
HRESULT GetData(ID3D11Asynchronous *pAsync, void *pData, UINT DataSize, UINT GetDataFlags);
void SetPredication(ID3D11Predicate *pPredicate, BOOL PredicateValue);
void GSSetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> *const *ppShaderResourceViews);
void GSSetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> *const *ppSamplers);
void OMSetRenderTargets(UINT NumViews, gfx::ID3D11RenderTargetView<ABI> *const *,
gfx::ID3D11DepthStencilView<ABI> *pDepthStencilView);
void OMSetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs,
gfx::ID3D11RenderTargetView<ABI> *const *ppRenderTargetViews,
gfx::ID3D11DepthStencilView<ABI> *pDepthStencilView,
UINT UAVStartSlot, UINT NumUAVs,
gfx::ID3D11UnorderedAccessView<ABI> *const *ppUnorderedAccessViews,
UINT const *pUAVInitialCounts);
void OMSetBlendState(gfx::ID3D11BlendState<ABI> *pBlendState, FLOAT const BlendFactor[4], UINT SampleMask);
void OMSetDepthStencilState(gfx::ID3D11DepthStencilState<ABI> *pDepthStencilState, UINT StencilRef);
void SOSetTargets(UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppSOTargets, UINT const *pOffsets);
void DrawAuto();
void DrawIndexedInstancedIndirect(gfx::ID3D11Buffer<ABI> *pBufferForArgs, UINT AlignedByteOffsetForArgs);
void DrawInstancedIndirect(gfx::ID3D11Buffer<ABI> *pBufferForArgs, UINT AlignedByteOffsetForArgs);
void Dispatch(UINT ThreadGroupCountX, UINT ThreadGroupCountY, UINT ThreadGroupCountZ);
void DispatchIndirect(gfx::ID3D11Buffer<ABI> *pBufferForArgs, UINT AlignedByteOffsetForArgs);
void RSSetState(gfx::ID3D11RasterizerState<ABI> *pRasterizerState);
void RSSetViewports(UINT NumViewports, D3D11_VIEWPORT const *pViewports);
void RSSetScissorRects(UINT NumRects, D3D11_RECT const *pRects);
void CopySubresourceRegion(gfx::ID3D11Resource<ABI> *pDstResource, UINT DstSubresource, UINT DstX, UINT DstY,
UINT DstZ, gfx::ID3D11Resource<ABI> *pSrcResource, UINT SrcSubresource,
D3D11_BOX const *pSrcBox);
void CopyResource(gfx::ID3D11Resource<ABI> *pDstResource, gfx::ID3D11Resource<ABI> *pSrcResource);
void UpdateSubresource(gfx::ID3D11Resource<ABI> *pDstResource, UINT DstSubresource, D3D11_BOX const *pDstBox,
void const *pSrcData, UINT SrcRowPitch, UINT SrcDepthPitch);
void CopyStructureCount(gfx::ID3D11Buffer<ABI> *pDstBuffer, UINT DstAlignedByteOffset,
gfx::ID3D11UnorderedAccessView<ABI> *pSrcView);
void ClearRenderTargetView(gfx::ID3D11RenderTargetView<ABI> *pRenderTargetView, FLOAT const ColorRGBA[4]);
void ClearUnorderedAccessViewUint(gfx::ID3D11UnorderedAccessView<ABI> *pUnorderedAccessView, UINT const Values[4]);
void ClearUnorderedAccessViewFloat(gfx::ID3D11UnorderedAccessView<ABI> *pUnorderedAccessView,
FLOAT const Values[4]);
void ClearDepthStencilView(gfx::ID3D11DepthStencilView<ABI> *pDepthStencilView, UINT ClearFlags, FLOAT Depth,
UINT8 Stencil);
void GenerateMips(gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void SetResourceMinLOD(gfx::ID3D11Resource<ABI> *pResource, FLOAT MinLOD);
FLOAT GetResourceMinLOD(gfx::ID3D11Resource<ABI> *pResource);
void ResolveSubresource(gfx::ID3D11Resource<ABI> *pDstResource, UINT DstSubresource,
gfx::ID3D11Resource<ABI> *pSrcResource, UINT SrcSubresource, DXGI_FORMAT Format);
void ExecuteCommandList(ID3D11CommandList *pCommandList, BOOL RestoreContextState);
void HSSetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> *const *ppShaderResourceViews);
void HSSetShader(gfx::ID3D11HullShader<ABI> *pHullShader);
void HSSetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> *const *ppSamplers);
void HSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers);
void DSSetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> *const *ppShaderResourceViews);
void DSSetShader(gfx::ID3D11DomainShader<ABI> *pDomainShader);
void DSSetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> *const *ppSamplers);
void DSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers);
void CSSetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> *const *ppShaderResourceViews);
void CSSetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs,
gfx::ID3D11UnorderedAccessView<ABI> *const *ppUnorderedAccessViews,
UINT const *pUAVInitialCounts);
void CSSetShader(gfx::ID3D11ComputeShader<ABI> *pComputeShader);
void CSSetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> *const *ppSamplers);
void CSSetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers);
void VSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers);
void PSGetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> **ppShaderResourceViews);
void PSGetShader(gfx::ID3D11PixelShader<ABI> **ppPixelShader, ID3D11ClassInstance **ppClassInstances,
UINT *pNumClassInstances);
void PSGetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> **ppSamplers);
void VSGetShader(gfx::ID3D11VertexShader<ABI> **ppVertexShader, ID3D11ClassInstance **ppClassInstances,
UINT *pNumClassInstances);
void PSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers);
void IAGetInputLayout(ID3D11InputLayout **ppInputLayout);
void IAGetVertexBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppVertexBuffers, UINT *pStrides,
UINT *pOffsets);
void IAGetIndexBuffer(gfx::ID3D11Buffer<ABI> **pIndexBuffer, DXGI_FORMAT *Format, UINT *Offset);
void GSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers);
void GSGetShader(gfx::ID3D11GeometryShader<ABI> **ppGeometryShader, ID3D11ClassInstance **ppClassInstances,
UINT *pNumClassInstances);
void IAGetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY *pTopology);
void VSGetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> **ppShaderResourceViews);
void VSGetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> **ppSamplers);
void GetPredication(ID3D11Predicate **ppPredicate, BOOL *pPredicateValue);
void GSGetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> **ppShaderResourceViews);
void GSGetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> **ppSamplers);
void OMGetRenderTargets(UINT NumViews, gfx::ID3D11RenderTargetView<ABI> **ppRenderTargetViews,
gfx::ID3D11DepthStencilView<ABI> **ppDepthStencilView);
void OMGetRenderTargetsAndUnorderedAccessViews(UINT NumRTVs, gfx::ID3D11RenderTargetView<ABI> **ppRenderTargetViews,
gfx::ID3D11DepthStencilView<ABI> **ppDepthStencilView,
UINT UAVStartSlot, UINT NumUAVs,
gfx::ID3D11UnorderedAccessView<ABI> **ppUnorderedAccessViews);
void OMGetBlendState(gfx::ID3D11BlendState<ABI> **ppBlendState, FLOAT BlendFactor[4], UINT *pSampleMask);
void OMGetDepthStencilState(gfx::ID3D11DepthStencilState<ABI> **ppDepthStencilState, UINT *pStencilRef);
void SOGetTargets(UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppSOTargets);
void RSGetState(gfx::ID3D11RasterizerState<ABI> **ppRasterizerState);
void RSGetViewports(UINT *pNumViewports, D3D11_VIEWPORT *pViewports);
void RSGetScissorRects(UINT *pNumRects, D3D11_RECT *pRects);
void HSGetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> **ppShaderResourceViews);
void HSGetShader(gfx::ID3D11HullShader<ABI> **ppHullShader, ID3D11ClassInstance **ppClassInstances,
UINT *pNumClassInstances);
void HSGetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> **ppSamplers);
void HSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers);
void DSGetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> **ppShaderResourceViews);
void DSGetShader(gfx::ID3D11DomainShader<ABI> **ppDomainShader, ID3D11ClassInstance **ppClassInstances,
UINT *pNumClassInstances);
void DSGetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> **ppSamplers);
void DSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers);
void CSGetShaderResources(UINT StartSlot, UINT NumViews,
gfx::ID3D11ShaderResourceView<ABI> **ppShaderResourceViews);
void CSGetUnorderedAccessViews(UINT StartSlot, UINT NumUAVs,
gfx::ID3D11UnorderedAccessView<ABI> **ppUnorderedAccessViews);
void CSGetShader(gfx::ID3D11ComputeShader<ABI> **ppComputeShader, ID3D11ClassInstance **ppClassInstances,
UINT *pNumClassInstances);
void CSGetSamplers(UINT StartSlot, UINT NumSamplers, gfx::ID3D11SamplerState<ABI> **ppSamplers);
void CSGetConstantBuffers(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers);
void ClearState();
void Flush();
D3D11_DEVICE_CONTEXT_TYPE GetType();
UINT GetContextFlags();
HRESULT FinishCommandList(BOOL RestoreDeferredContextState, ID3D11CommandList **ppCommandList);
//
// ID3D11DeviceContext1
//
void CopySubresourceRegion1(gfx::ID3D11Resource<ABI> *pDstResource, UINT DstSubresource, UINT DstX, UINT DstY,
UINT DstZ, gfx::ID3D11Resource<ABI> *pSrcResource, UINT SrcSubresource,
D3D11_BOX const *pSrcBox, UINT CopyFlags);
void UpdateSubresource1(gfx::ID3D11Resource<ABI> *pDstResource, UINT DstSubresource, D3D11_BOX const *pDstBox,
void const *pSrcData, UINT SrcRowPitch, UINT SrcDepthPitch, UINT CopyFlags);
void DiscardResource(gfx::ID3D11Resource<ABI> *pResource);
void DiscardView(gfx::ID3D11View<ABI> *pResourceView);
void VSSetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers,
UINT const *pFirstConstant, UINT const *pNumConstants);
void HSSetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers,
UINT const *pFirstConstant, UINT const *pNumConstants);
void DSSetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers,
UINT const *pFirstConstant, UINT const *pNumConstants);
void GSSetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers,
UINT const *pFirstConstant, UINT const *pNumConstants);
void PSSetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers,
UINT const *pFirstConstant, UINT const *pNumConstants);
void CSSetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> *const *ppConstantBuffers,
UINT const *pFirstConstant, UINT const *pNumConstants);
void VSGetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers,
UINT *pFirstConstant, UINT *pNumConstants);
void HSGetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers,
UINT *pFirstConstant, UINT *pNumConstants);
void DSGetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers,
UINT *pFirstConstant, UINT *pNumConstants);
void GSGetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers,
UINT *pFirstConstant, UINT *pNumConstants);
void PSGetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers,
UINT *pFirstConstant, UINT *pNumConstants);
void CSGetConstantBuffers1(UINT StartSlot, UINT NumBuffers, gfx::ID3D11Buffer<ABI> **ppConstantBuffers,
UINT *pFirstConstant, UINT *pNumConstants);
void SwapDeviceContextState(ID3DDeviceContextState *pState, ID3DDeviceContextState **ppPreviousState);
void ClearView(gfx::ID3D11View<ABI> *pView, FLOAT const Color[4], D3D11_RECT const *pRect, UINT NumRects);
void DiscardView1(gfx::ID3D11View<ABI> *pResourceView, D3D11_RECT const *pRects, UINT NumRects);
//
// ID3D11DeviceContext2
//
HRESULT UpdateTileMappings(gfx::ID3D11Resource<ABI> *pTiledResource, UINT NumTiledResourceRegions,
D3D11_TILED_RESOURCE_COORDINATE const *pTiledResourceRegionStartCoordinates,
D3D11_TILE_REGION_SIZE const *pTiledResourceRegionSizes,
gfx::ID3D11Buffer<ABI> *pTilePool, UINT NumRanges, UINT const *pRangeFlags,
UINT const *pTilePoolStartOffsets, UINT const *pRangeTileCounts, UINT Flags);
HRESULT CopyTileMappings(gfx::ID3D11Resource<ABI> *pDestTiledResource,
D3D11_TILED_RESOURCE_COORDINATE const *pDestRegionStartCoordinate,
gfx::ID3D11Resource<ABI> *pSourceTiledResource,
D3D11_TILED_RESOURCE_COORDINATE const *pSourceRegionStartCoordinate,
D3D11_TILE_REGION_SIZE const *pTileRegionSize, UINT Flags);
void CopyTiles(gfx::ID3D11Resource<ABI> *pTiledResource,
D3D11_TILED_RESOURCE_COORDINATE const *pTileRegionStartCoordinate,
D3D11_TILE_REGION_SIZE const *pTileRegionSize, gfx::ID3D11Buffer<ABI> *pBuffer,
UINT64 BufferStartOffsetInBytes, UINT Flags);
void UpdateTiles(gfx::ID3D11Resource<ABI> *pDestTiledResource,
D3D11_TILED_RESOURCE_COORDINATE const *pDestTileRegionStartCoordinate,
D3D11_TILE_REGION_SIZE const *pDestTileRegionSize, void const *pSourceTileData, UINT Flags);
HRESULT ResizeTilePool(gfx::ID3D11Buffer<ABI> *pTilePool, UINT64 NewSizeInBytes);
void TiledResourceBarrier(gfx::ID3D11DeviceChild<ABI> *pTiledResourceOrViewAccessBeforeBarrier,
gfx::ID3D11DeviceChild<ABI> *pTiledResourceOrViewAccessAfterBarrier);
//
// ID3D11DeviceContextX
//
INT PIXBeginEvent(LPCWSTR Name);
INT PIXEndEvent();
void PIXSetMarker(LPCWSTR Name);
BOOL PIXGetStatus();
HRESULT PIXGpuCaptureNextFrame(UINT Flags, LPCWSTR lpOutputFileName);
HRESULT PIXGpuBeginCapture(UINT Flags, LPCWSTR lpOutputFileName);
HRESULT PIXGpuEndCapture();
void StartCounters(gfx::ID3D11CounterSetX *pCounterSet);
void SampleCounters(gfx::ID3D11CounterSampleX *pCounterSample);
void StopCounters();
HRESULT GetCounterData(gfx::ID3D11CounterSampleX *pCounterSample, gfx::D3D11X_COUNTER_DATA *pData,
UINT GetCounterDataFlags);
void FlushGpuCaches(gfx::ID3D11Resource<ABI> *pResource);
void FlushGpuCacheRange(UINT Flags, void *pBaseAddress, SIZE_T SizeInBytes);
void InsertWaitUntilIdle(UINT Flags);
UINT64 InsertFence(UINT Flags);
void InsertWaitOnFence(UINT Flags, UINT64 Fence);
void RemapConstantBufferInheritance(gfx::D3D11_STAGE Stage, UINT Slot, gfx::D3D11_STAGE InheritStage,
UINT InheritSlot);
void RemapShaderResourceInheritance(gfx::D3D11_STAGE Stage, UINT Slot, gfx::D3D11_STAGE InheritStage,
UINT InheritSlot);
void RemapSamplerInheritance(gfx::D3D11_STAGE Stage, UINT Slot, gfx::D3D11_STAGE InheritStage, UINT InheritSlot);
void RemapVertexBufferInheritance(UINT Slot, UINT InheritSlot);
void PSSetFastConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer);
void PSSetFastShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void PSSetFastSampler(UINT Slot, gfx::ID3D11SamplerState<ABI> *pSampler);
void VSSetFastConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer);
void VSSetFastShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void VSSetFastSampler(UINT Slot, gfx::ID3D11SamplerState<ABI> *pSampler);
void GSSetFastConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer);
void GSSetFastShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void GSSetFastSampler(UINT Slot, gfx::ID3D11SamplerState<ABI> *pSampler);
void CSSetFastConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer);
void CSSetFastShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void CSSetFastSampler(UINT Slot, gfx::ID3D11SamplerState<ABI> *pSampler);
void HSSetFastConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer);
void HSSetFastShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void HSSetFastSampler(UINT Slot, gfx::ID3D11SamplerState<ABI> *pSampler);
void DSSetFastConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer);
void DSSetFastShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView);
void DSSetFastSampler(UINT Slot, gfx::ID3D11SamplerState<ABI> *pSampler);
void IASetFastVertexBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pVertexBuffer, UINT Stride);
void IASetFastIndexBuffer(UINT HardwareIndexFormat, gfx::ID3D11Buffer<ABI> *pIndexBuffer);
void PSSetPlacementConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer, void *pBaseAddress);
void PSSetPlacementShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView,
void *pBaseAddress);
void VSSetPlacementConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer, void *pBaseAddress);
void VSSetPlacementShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView,
void *pBaseAddress);
void GSSetPlacementConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer, void *pBaseAddress);
void GSSetPlacementShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView,
void *pBaseAddress);
void CSSetPlacementConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer, void *pBaseAddress);
void CSSetPlacementShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView,
void *pBaseAddress);
void HSSetPlacementConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer, void *pBaseAddress);
void HSSetPlacementShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView,
void *pBaseAddress);
void DSSetPlacementConstantBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pConstantBuffer, void *pBaseAddress);
void DSSetPlacementShaderResource(UINT Slot, gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView,
void *pBaseAddress);
void IASetPlacementVertexBuffer(UINT Slot, gfx::ID3D11Buffer<ABI> *pVertexBuffer, void *pBaseAddress, UINT Stride);
void IASetPlacementIndexBuffer(UINT HardwareIndexFormat, gfx::ID3D11Buffer<ABI> *pIndexBuffer, void *pBaseAddress);
void HSSetTessellationParameters(gfx::D3D11X_TESSELLATION_PARAMETERS const *pTessellationParameters);
void HSGetLastUsedTessellationParameters(gfx::D3D11X_TESSELLATION_PARAMETERS *pTessellationParameters);
void CSEnableAutomaticGpuFlush(BOOL Enable);
void GpuSendPipelinedEvent(gfx::D3D11X_GPU_PIPELINED_EVENT Event);
HRESULT Suspend(UINT Flags);
HRESULT Resume();
void BeginCommandListExecution(UINT Flags);
void EndCommandListExecution();
void SetGraphicsShaderLimits(gfx::D3D11X_GRAPHICS_SHADER_LIMITS const *pShaderLimits);
void SetComputeShaderLimits(gfx::D3D11X_COMPUTE_SHADER_LIMITS const *pShaderLimits);
void SetPredicationBuffer(gfx::ID3D11Buffer<ABI> *pBuffer, UINT Offset, UINT Flags);
void OMSetDepthBounds(FLOAT min, FLOAT max);
void OMSetDepthStencilStateX(gfx::ID3D11DepthStencilState<ABI> *pDepthStencilState);
void OMSetSampleMask(UINT64 QuadSampleMask);
UINT32 *MakeCeSpace();
void SetFastResources_Debug(UINT *pTableStart, UINT *pTableEnd);
void BeginResourceBatch(void *pBuffer, UINT BufferSize);
UINT EndResourceBatch(UINT *pSizeNeeded);
void SetFastResourcesFromBatch_Debug(void *pBatch, UINT Size);
void CSPlaceUnorderedAccessView(UINT Slot, gfx::D3D11X_DESCRIPTOR_UNORDERED_ACCESS_VIEW *const pDescriptor,
UINT64 Offset);
void WriteValueEndOfPipe(void *pDestination, UINT Value, UINT Flags);
void CopyMemoryToMemory(void *pDstAddress, void *pSrcAddress, SIZE_T SizeBytes);
void FillMemoryWithValue(void *pDstAddress, SIZE_T SizeBytes, UINT FillValue);
void BeginProcessVideoResource(gfx::ID3D11Resource<ABI> *pResource, UINT SubResource);
void EndProcessVideoResource(gfx::ID3D11Resource<ABI> *pResource, UINT SubResource);
HRESULT StartThreadTrace(gfx::D3D11X_THREAD_TRACE_DESC const *pDesc, void *pDstAddressShaderEngine0,
void *pDstAddressShaderEngine1, SIZE_T BufferSizeBytes);
void StopThreadTrace(void *pDstAddressTraceSize);
void InsertThreadTraceMarker(UINT Marker);
void IASetPrimitiveResetIndex(UINT ResetIndex);
void SetShaderResourceViewMinLOD(gfx::ID3D11ShaderResourceView<ABI> *pShaderResourceView, FLOAT MinLOD);
void InsertWaitOnPresent(UINT Flags, gfx::ID3D11Resource<ABI> *pBackBuffer);
void ClearRenderTargetViewX(gfx::ID3D11RenderTargetView<ABI> *pRenderTargetView, UINT Flags,
FLOAT const ColorRGBA[4]);
UINT GetResourceCompression(gfx::ID3D11Resource<ABI> *pResource);
UINT GetResourceCompressionX(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pResource);
void DecompressResource(gfx::ID3D11Resource<ABI> *pDstResource, UINT DstSubresource,
gfx::D3D11X_POINT const *pDstPoint, gfx::ID3D11Resource<ABI> *pSrcResource,
UINT SrcSubresource, gfx::D3D11X_RECT const *pSrcRect,
DXGI_FORMAT DecompressFormat, UINT DecompressFlags);
void DecompressResourceX(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDstResource, UINT DstSubresource,
gfx::D3D11X_POINT const *pDstPoint, gfx::D3D11X_DESCRIPTOR_RESOURCE *pSrcResource,
UINT SrcSubresource, gfx::D3D11X_RECT const *pSrcRect, gfx::D3D11X_FORMAT DecompressFormat,
UINT DecompressFlags);
void GSSetParameters(gfx::D3D11X_GS_PARAMETERS const *pGsParameters);
void GSGetLastUsedParameters(gfx::D3D11X_GS_PARAMETERS *pGsParameters);
void MultiDrawIndexedInstancedIndirect(UINT PrimitiveCount, gfx::ID3D11Buffer<ABI> *pBufferForArgs,
UINT AlignedByteOffsetForArgs, UINT StrideByteOffsetForArgs, UINT Flags);
void MultiDrawInstancedIndirect(UINT PrimitiveCount, gfx::ID3D11Buffer<ABI> *pBufferForArgs,
UINT AlignedByteOffsetForArgs, UINT StrideByteOffsetForArgs, UINT Flags);
void MultiDrawIndexedInstancedIndirectAuto(gfx::ID3D11Buffer<ABI> *pBufferForPrimitiveCount,
UINT AlignedByteOffsetForPrimitiveCount,
gfx::ID3D11Buffer<ABI> *pBufferForArgs, UINT AlignedByteOffsetForArgs,
UINT StrideByteOffsetForArgs, UINT Flags);
void MultiDrawInstancedIndirectAuto(gfx::ID3D11Buffer<ABI> *pBufferForPrimitiveCount,
UINT AlignedByteOffsetForPrimitiveCount, gfx::ID3D11Buffer<ABI> *pBufferForArgs,
UINT AlignedByteOffsetForArgs, UINT StrideByteOffsetForArgs, UINT Flags);
HRESULT RSGetMSAASettingsForQuality(gfx::D3D11X_MSAA_SCAN_CONVERTER_SETTINGS *pMSAASCSettings,
gfx::D3D11X_MSAA_EQAA_SETTINGS *pEQAASettings,
gfx::D3D11X_MSAA_SAMPLE_PRIORITIES *pCentroidPriorities,
gfx::D3D11X_MSAA_SAMPLE_POSITIONS *pSamplePositions, UINT LogSampleCount,
UINT SampleQuality);
void RSSetScanConverterMSAASettings(gfx::D3D11X_MSAA_SCAN_CONVERTER_SETTINGS const *pMSAASCSettings);
void RSSetEQAASettings(gfx::D3D11X_MSAA_EQAA_SETTINGS const *pEQAASettings);
void RSSetSamplePositions(gfx::D3D11X_MSAA_SAMPLE_PRIORITIES const *pSamplesPriorities,
gfx::D3D11X_MSAA_SAMPLE_POSITIONS const *pSamplePositions);
void SetResourceCompression(gfx::ID3D11Resource<ABI> *pResource, UINT Compression);
void SetResourceCompressionX(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pResource, UINT Compression);
void SetGDSRange(gfx::D3D11X_GDS_REGION_TYPE RegionType, UINT OffsetDwords, UINT NumDwords);
void WriteGDS(gfx::D3D11X_GDS_REGION_TYPE RegionType, UINT OffsetDwords, UINT NumDwords, UINT const *pCounterValues,
UINT Flags);
void ReadGDS(gfx::D3D11X_GDS_REGION_TYPE RegionType, UINT OffsetDwords, UINT NumDwords, UINT *pCounterValues,
UINT Flags);
void VSSetShaderUserData(UINT StartSlot, UINT NumRegisters, UINT const *pData);
void HSSetShaderUserData(UINT StartSlot, UINT NumRegisters, UINT const *pData);
void DSSetShaderUserData(UINT StartSlot, UINT NumRegisters, UINT const *pData);
void GSSetShaderUserData(UINT StartSlot, UINT NumRegisters, UINT const *pData);
void PSSetShaderUserData(UINT StartSlot, UINT NumRegisters, UINT const *pData);
void CSSetShaderUserData(UINT StartSlot, UINT NumRegisters, UINT const *pData);
void InsertWaitOnMemory(void const *pAddress, UINT Flags, D3D11_COMPARISON_FUNC ComparisonFunction,
UINT ReferenceValue, UINT Mask);
void WriteTimestampToMemory(void *pDstAddress);
void WriteTimestampToBuffer(gfx::ID3D11Buffer<ABI> *pBuffer, UINT OffsetBytes);
void StoreConstantRam(UINT Flags, gfx::ID3D11Buffer<ABI> *pBuffer, UINT BufferOffsetInBytes,
UINT CeRamOffsetInBytes, UINT SizeInBytes);
void LoadConstantRam(UINT Flags, gfx::ID3D11Buffer<ABI> *pBuffer, UINT BufferOffsetInBytes, UINT CeRamOffsetInBytes,
UINT SizeInBytes);
void WriteQuery(D3D11_QUERY QueryType, UINT QueryIndex, UINT Flags, gfx::ID3D11Buffer<ABI> *pBuffer,
UINT OffsetInBytes, UINT StrideInBytes);
void ResetQuery(D3D11_QUERY QueryType, UINT QueryIndex, UINT Flags);
void ConfigureQuery(D3D11_QUERY QueryType, void const *pConfiguration, UINT ConfigurationSize);
void SetShaderUserData(gfx::D3D11X_HW_STAGE ShaderStage, UINT StartSlot, UINT NumRegisters, UINT const *pData);
void SetPixelShaderDepthForceZOrder(BOOL ForceOrder);
void SetPredicationFromQuery(D3D11_QUERY QueryType, gfx::ID3D11Buffer<ABI> *pBuffer, UINT OffsetInBytes,
UINT Flags);
void SetBorderColorPalette(gfx::ID3D11Buffer<ABI> *pBuffer, UINT OffsetInBytes, UINT Flags);
void WriteValueEndOfPipe64(void *pDestination, UINT64 Value, UINT Flags);
void InsertWaitOnMemory64(void const *pAddress, UINT Flags, D3D11_COMPARISON_FUNC ComparisonFunction,
UINT64 ReferenceValue);
void LoadConstantRamImmediate(UINT Flags, void const *pBuffer, UINT CeRamOffsetInBytes, UINT SizeInBytes);
void SetScreenExtentsQuery(UINT Value);
void CollectScreenExtents(UINT Flags, UINT AddressCount, UINT64 const *pDestinationAddresses, USHORT ZMin,
USHORT ZMax);
void FillResourceWithValue(gfx::ID3D11Resource<ABI> *pDstResource, UINT FillValue);
void SetDrawBalancing(UINT BalancingMode, UINT Flags);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DeviceContextX<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

186
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11Resource.h Normal file
View File

@@ -0,0 +1,186 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11Resource : public gfx::ID3D11Resource<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11Resource
//
void GetType(D3D11_RESOURCE_DIMENSION *pDimension);
void SetEvictionPriority(uint32_t EvictionPriority);
uint32_t GetEvictionPriority();
void GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Resource<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11Texture1D : public gfx::ID3D11Texture1D<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11Resource
//
void GetType(D3D11_RESOURCE_DIMENSION *pDimension);
void SetEvictionPriority(uint32_t EvictionPriority);
uint32_t GetEvictionPriority();
void GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc);
//
// ID3D11Texture1D
//
void GetDesc(D3D11_TEXTURE1D_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Texture1D<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11Texture2D : public gfx::ID3D11Texture2D<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11Resource
//
void GetType(D3D11_RESOURCE_DIMENSION *pDimension);
void SetEvictionPriority(uint32_t EvictionPriority);
uint32_t GetEvictionPriority();
void GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc);
//
// ID3D11Texture2D
//
void GetDesc(D3D11_TEXTURE2D_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Texture2D<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11Texture3D : public gfx::ID3D11Texture3D<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11Resource
//
void GetType(D3D11_RESOURCE_DIMENSION *pDimension);
void SetEvictionPriority(uint32_t EvictionPriority);
uint32_t GetEvictionPriority();
void GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc);
//
// ID3D11Texture3D
//
void GetDesc(D3D11_TEXTURE3D_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Texture3D<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11Buffer : public gfx::ID3D11Buffer<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11Resource
//
void GetType(D3D11_RESOURCE_DIMENSION *pDimension);
void SetEvictionPriority(uint32_t EvictionPriority);
uint32_t GetEvictionPriority();
void GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc);
//
// ID3D11Buffer
//
void GetDesc(D3D11_TEXTURE1D_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Buffer<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

46
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11Runtime.h Normal file
View File

@@ -0,0 +1,46 @@
#pragma once
#include "ID3D11Device.h"
#include "ID3D11DeviceContext.h"
static ID3D11Device2 *pDev2 = nullptr;
static ID3D11DeviceContext2 *pCtx2 = nullptr;
struct ID3D11Runtime
{
virtual HRESULT CreateDevice(void **ppDevice, void **ppContext) = 0;
};
template <abi_t ABI> struct D3D11Runtime : public ID3D11Runtime
{
HRESULT CreateDevice(void **ppDevice, void **ppContext) override
{
ID3D11Device *pDevice = nullptr;
ID3D11DeviceContext *pContext = nullptr;
D3D_FEATURE_LEVEL FeatureLevels[] = {D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0};
auto hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, FeatureLevels, 2, D3D11_SDK_VERSION,
&pDevice, nullptr, &pContext);
if (FAILED(hr))
{
MessageBoxA(nullptr, "Failed to create the D3D11 Device!", "Error!", MB_OK);
}
ID3D11Device2 *pDevice2 = nullptr;
ID3D11DeviceContext2 *pContext2 = nullptr;
pDevice->QueryInterface(IID_PPV_ARGS(&pDevice2));
pContext->QueryInterface(IID_PPV_ARGS(&pContext2));
pDev2 = pDevice2;
pCtx2 = pContext2;
pDevice->Release();
pContext->Release();
*ppDevice = new D3D11DeviceX<ABI>(pDevice2);
*ppContext = new D3D11DeviceContextX<ABI>(pContext2);
return hr;
};
};

151
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11Shader.h Normal file
View File

@@ -0,0 +1,151 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11VertexShader : public gfx::ID3D11VertexShader<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11VertexShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11PixelShader : public gfx::ID3D11PixelShader<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11PixelShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11ComputeShader : public gfx::ID3D11ComputeShader<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11ComputeShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11GeometryShader : public gfx::ID3D11GeometryShader<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11GeometryShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11HullShader : public gfx::ID3D11HullShader<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11HullShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11DomainShader : public gfx::ID3D11DomainShader<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DomainShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

123
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11State.h Normal file
View File

@@ -0,0 +1,123 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11SamplerState : public gfx::ID3D11SamplerState<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11SamplerState
//
void GetDesc(D3D11_SAMPLER_DESC *pDesc);
void GetDescX(gfx::D3D11X_SAMPLER_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11SamplerState<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11RasterizerState : public gfx::ID3D11RasterizerState<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11RasterizerState
//
void GetDesc(D3D11_RASTERIZER_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11RasterizerState<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11BlendState : public gfx::ID3D11BlendState<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11BlendState
//
void GetDesc(D3D11_BLEND_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11BlendState<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11DepthStencilState : public gfx::ID3D11DepthStencilState<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11DepthStencilState
//
void GetDesc(D3D11_DEPTH_STENCIL_DESC *pDesc);
void GetDescX(D3D11_DEPTH_STENCIL_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DepthStencilState<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

173
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/ID3D11View.h Normal file
View File

@@ -0,0 +1,173 @@
#pragma once
#include "d3d11_x.g.h"
template <abi_t ABI> class D3D11View : public gfx::ID3D11View<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11View
//
void GetResource(gfx::ID3D11Resource<ABI> **ppResource);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11View<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11ShaderResourceView : public gfx::ID3D11ShaderResourceView<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11View
//
void GetResource(gfx::ID3D11Resource<ABI> **ppResource);
//
// ID3D11ShaderResourceView
//
void GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc);
void GetFormatX(gfx::D3D11X_SRV_FORMAT*);
int32_t SetFormatX(gfx::D3D11X_SRV_FORMAT const *);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11ShaderResourceView<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11RenderTargetView : public gfx::ID3D11RenderTargetView<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11View
//
void GetResource(gfx::ID3D11Resource<ABI> **ppResource);
//
// ID3D11RenderTargetView
//
void GetDesc(D3D11_RENDER_TARGET_VIEW_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11RenderTargetView<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11DepthStencilView : public gfx::ID3D11DepthStencilView<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11View
//
void GetResource(gfx::ID3D11Resource<ABI> **ppResource);
//
// ID3D11DepthStencilView
//
void GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DepthStencilView<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);
template <abi_t ABI> class D3D11UnorderedAccessView : public gfx::ID3D11UnorderedAccessView<ABI>
{
public:
//
// IUnknown
//
HRESULT QueryInterface(REFIID riid, void **ppvObject);
ULONG AddRef();
ULONG Release();
//
// ID3D11DeviceChild
//
void GetDevice(gfx::ID3D11Device<ABI> **ppDevice);
HRESULT GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData);
HRESULT SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData);
HRESULT SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData);
HRESULT SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData);
//
// ID3D11View
//
void GetResource(gfx::ID3D11Resource<ABI> **ppResource);
//
// ID3D11UnorderedAccessView
//
void GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc);
};
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11UnorderedAccessView<ABI>
D3D11_DECLARE_ABI_TEMPLATES(extern);

2625
projects/WinDurango.D3D11X/include/WinDurango.D3D11X/d3d11_x.g.h Normal file
View File

File diff suppressed because it is too large Load Diff

206
projects/WinDurango.D3D11X/src/ID3D11DMAEngineContext.cpp Normal file
View File

@@ -0,0 +1,206 @@
#include "ID3D11DMAEngineContext.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11DMAEngineContextX<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11DMAEngineContextX<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11DMAEngineContextX<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11DMAEngineContextX
//
template <abi_t ABI> D3D11_DEVICE_CONTEXT_TYPE D3D11DMAEngineContextX<ABI>::GetType()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI>
void D3D11DMAEngineContextX<ABI>::CopyResource(gfx::ID3D11Resource<ABI> *v1, gfx::ID3D11Resource<ABI> *v2, uint32_t v3)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DMAEngineContextX<ABI>::CopySubresourceRegion(gfx::ID3D11Resource<ABI> *v1, uint32_t v2, uint32_t v3,
uint32_t v4, uint32_t v5, gfx::ID3D11Resource<ABI> *v6,
uint32_t v7, D3D11_BOX const *v8, uint32_t v9)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::LZDecompressBuffer(gfx::ID3D11Buffer<ABI> *v1, uint32_t v2,
gfx::ID3D11Buffer<ABI> *v3, uint32_t v4, uint32_t v5,
uint32_t v6)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::LZDecompressTexture(gfx::ID3D11Resource<ABI> *v1, uint32_t v2, uint32_t v3,
uint32_t v4, uint32_t v5, gfx::ID3D11Buffer<ABI> *v6,
uint32_t v7)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::LZCompressBuffer(gfx::ID3D11Buffer<ABI> *v1, uint32_t v2,
gfx::ID3D11Buffer<ABI> *v3, uint32_t v4, uint32_t v5, uint32_t v6)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::LZCompressTexture(gfx::ID3D11Buffer<ABI> *v1, gfx::ID3D11Resource<ABI> *v2,
uint32_t v3, D3D11_BOX const *v4, uint32_t v5)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::JPEGDecode(gfx::ID3D11Resource<ABI> *v1, uint32_t v2, uint32_t v3, uint32_t v4,
uint32_t v5, gfx::ID3D11Buffer<ABI> *v6, uint32_t v7)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> uint64_t D3D11DMAEngineContextX<ABI>::InsertFence(uint32_t v1)
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::InsertWaitOnFence(uint32_t v1, uint64_t v2)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11DMAEngineContextX<ABI>::Submit()
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::CopyLastErrorCodeToMemory(void *v1)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DMAEngineContextX<ABI>::CopyLastErrorCodeToBuffer(gfx::ID3D11Buffer<ABI> *v1, uint32_t v2)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::CopyMemoryToMemory(void *v1, void *v2, uint64_t v3)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::FillMemoryWithValue(void *v1, uint64_t v2, uint32_t v3)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::FillResourceWithValue(gfx::ID3D11Resource<ABI> *v1, uint32_t v2)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DMAEngineContextX<ABI>::LZDecompressMemory(void *v1, void *v2, uint32_t v3, uint32_t v4)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DMAEngineContextX<ABI>::LZCompressMemory(void *v1, void *v2, uint32_t v3, uint32_t v4)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::WriteTimestampToMemory(void *v1)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::WriteTimestampToBuffer(gfx::ID3D11Buffer<ABI> *v1, uint32_t v2)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DMAEngineContextX<ABI>::WriteValueBottomOfPipe(void *v1, uint32_t v2)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DMAEngineContextX<ABI>::InsertWaitOnMemory(void const *v1, uint32_t v2, D3D11_COMPARISON_FUNC v3, uint32_t v4,
uint32_t v5)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DMAEngineContextX<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

647
projects/WinDurango.D3D11X/src/ID3D11Device.cpp Normal file
View File

@@ -0,0 +1,647 @@
#include "ID3D11Device.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11DeviceX<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11DeviceX<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11Device
//
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateBuffer(D3D11_BUFFER_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Buffer<ABI> **ppBuffer)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateTexture1D(D3D11_TEXTURE1D_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Texture1D<ABI> **ppTexture1D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateTexture2D(D3D11_TEXTURE2D_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Texture2D<ABI> **ppTexture2D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateTexture3D(D3D11_TEXTURE3D_DESC const *pDesc, D3D11_SUBRESOURCE_DATA const *pData,
gfx::ID3D11Texture3D<ABI> **ppTexture3D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateShaderResourceView(gfx::ID3D11Resource<ABI> *pResource,
D3D11_SHADER_RESOURCE_VIEW_DESC const *pDesc,
gfx::ID3D11ShaderResourceView<ABI> **ppSRV)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateUnorderedAccessView(gfx::ID3D11Resource<ABI> *pResource,
D3D11_UNORDERED_ACCESS_VIEW_DESC const *pDesc,
gfx::ID3D11UnorderedAccessView<ABI> **ppUAV)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateRenderTargetView(gfx::ID3D11Resource<ABI> *pResource,
D3D11_RENDER_TARGET_VIEW_DESC const *pDesc,
gfx::ID3D11RenderTargetView<ABI> **ppRTV)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDepthStencilView(gfx::ID3D11Resource<ABI> *pResource,
D3D11_DEPTH_STENCIL_VIEW_DESC const *pDesc,
gfx::ID3D11DepthStencilView<ABI> **ppDSV)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateInputLayout(D3D11_INPUT_ELEMENT_DESC const *pDesc, uint32_t NumElements,
void const *pShaderBytecodeWithInputSignature, uint64_t BytecodeLength,
ID3D11InputLayout **ppInputLayout)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateVertexShader(void const *pBytecode, uint64_t BytecodeLength,
ID3D11ClassLinkage *pClassLinkage, gfx::ID3D11VertexShader<ABI> **ppVS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateGeometryShader(void const *pBytecode, uint64_t BytecodeLentgh,
ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11GeometryShader<ABI> **ppGS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateGeometryShaderWithStreamOutput(void const *pBytecode, uint64_t BytecodeLentgh,
D3D11_SO_DECLARATION_ENTRY const *pSODeclaration,
uint32_t NumEntries, uint32_t const *pStrides,
uint32_t NumStides, uint32_t RasterizedStream,
ID3D11ClassLinkage *pClassLinkage,
gfx::ID3D11GeometryShader<ABI> **ppGS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePixelShader(void const *pBytecode, uint64_t BytecodeLentgh,
ID3D11ClassLinkage *pClassLinkage, gfx::ID3D11PixelShader<ABI> **ppPS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateHullShader(void const *pBytecode, uint64_t BytecodeLentgh,
ID3D11ClassLinkage *pClassLinkage, gfx::ID3D11HullShader<ABI> **ppHS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDomainShader(void const *pBytecode, uint64_t BytecodeLentgh,
ID3D11ClassLinkage *pClassLinkage, gfx::ID3D11DomainShader<ABI> **ppDS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateComputeShader(void const *pBytecode, uint64_t BytecodeLentgh,
ID3D11ClassLinkage *pClassLinkage, gfx::ID3D11ComputeShader<ABI> **ppCS)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::CreateClassLinkage(ID3D11ClassLinkage **ppClassLinkage)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateBlendState(D3D11_BLEND_DESC const *pDesc, gfx::ID3D11BlendState<ABI> **ppBlendState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDepthStencilState(D3D11_DEPTH_STENCIL_DESC const *pDesc,
gfx::ID3D11DepthStencilState<ABI> **ppDepthStencilState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateRasterizerState(D3D11_RASTERIZER_DESC const *pDesc,
gfx::ID3D11RasterizerState<ABI> **ppRasterizerState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateSamplerState(D3D11_SAMPLER_DESC const *pDesc,
gfx::ID3D11SamplerState<ABI> **ppSamplerState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::CreateQuery(D3D11_QUERY_DESC const *pDesc, ID3D11Query **ppQuery)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePredicate(D3D11_QUERY_DESC const *pDesc, ID3D11Predicate **ppPrediticate)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateCounter(D3D11_COUNTER_DESC const *pDesc, ID3D11Counter **ppCounter)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDeferredContext(uint32_t Flags, gfx::ID3D11DeviceContext<ABI> **ppDeferredContext)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::OpenSharedResource(void *pResource, _GUID const &retInterface, void **ppResource)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::CheckFormatSupport(DXGI_FORMAT Format, uint32_t *pFormatSupport)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CheckMultisampleQualityLevels(DXGI_FORMAT Format, uint32_t SampleCount,
uint32_t *pNumQualityLevels)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> void D3D11DeviceX<ABI>::CheckCounterInfo(D3D11_COUNTER_INFO *pCounterInfo)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CheckCounter(D3D11_COUNTER_DESC const *pDesc, D3D11_COUNTER_TYPE *pCounterType,
uint32_t *pActiveCounters, char *szName, uint32_t *pNameLength, char *szUnits,
uint32_t *pUnitsLength, char *szDescription, uint32_t *pDescriptionLength)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CheckFeatureSupport(D3D11_FEATURE Feature, void *pFeatureSupportData,
uint32_t FeatureSupportDataSize)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> D3D_FEATURE_LEVEL D3D11DeviceX<ABI>::GetFeatureLevel()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> uint32_t D3D11DeviceX<ABI>::GetCreationFlags()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::GetDeviceRemovedReason()
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> void D3D11DeviceX<ABI>::GetImmediateContext(gfx::ID3D11DeviceContext<ABI> **ppImmediateContext)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::SetExceptionMode(uint32_t ExceptionMode)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> uint32_t D3D11DeviceX<ABI>::GetExceptionMode()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11Device1
//
template <abi_t ABI> void D3D11DeviceX<ABI>::GetImmediateContext1(gfx::ID3D11DeviceContext1<ABI> **ppImmediateContext)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDeferredContext1(uint32_t Flags, gfx::ID3D11DeviceContext1<ABI> **ppDeferredContext1)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateBlendState1(D3D11_BLEND_DESC1 const *pDesc, ID3D11BlendState1 **ppBlendState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateRasterizerState1(D3D11_RASTERIZER_DESC1 const *pDesc,
ID3D11RasterizerState1 **ppRasterizerState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDeviceContextState(uint32_t Flags, D3D_FEATURE_LEVEL const *pFeatureLevels,
uint32_t FeatureLevels, uint32_t SDKVersion,
_GUID const &EmulatedInterface,
D3D_FEATURE_LEVEL *pChosenFeatureLevel,
ID3DDeviceContextState **ppContextState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::OpenSharedResource1(void *pResource, _GUID const &retInterface, void **ppResource)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::OpenSharedResourceByName(wchar_t const *pName, uint32_t dwDesiredAccess,
_GUID const &retInterface, void **ppResource)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11Device2
//
template <abi_t ABI> void D3D11DeviceX<ABI>::GetImmediateContext2(gfx::ID3D11DeviceContext2<ABI> **ppImmediateContext)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDeferredContext2(uint32_t Flags, gfx::ID3D11DeviceContext2<ABI> **ppDeferredContext)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::GetResourceTiling(gfx::ID3D11Resource<ABI> *pTiledResource,
uint32_t *pNumTilesForEntireResource, D3D11_PACKED_MIP_DESC *pPackedMipDesc,
D3D11_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
uint32_t *pNumSubresourceTilings, uint32_t FirstSubresourceTilingToGet,
D3D11_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CheckMultisampleQualityLevels1(DXGI_FORMAT Format, uint32_t SampleCount, uint32_t Flags,
uint32_t *pNumQualityLevels)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11DeviceX
//
template <abi_t ABI> void D3D11DeviceX<ABI>::GetImmediateContextX(gfx::ID3D11DeviceContextX<ABI> **ppImmediateContextX)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateCounterSet(gfx::D3D11X_COUNTER_SET_DESC const *pCounterSetDesc,
gfx::ID3D11CounterSetX **ppCounterSet)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::CreateCounterSample(gfx::ID3D11CounterSampleX **ppCounterSample)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::SetDriverHint(UINT Feature, UINT Value)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDmaEngineContext(gfx::D3D11_DMA_ENGINE_CONTEXT_DESC const *pDmaEngineContextDesc,
gfx::ID3D11DMAEngineContextX<ABI> **ppDmaDeviceContext)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> BOOL D3D11DeviceX<ABI>::IsFencePending(UINT64 Fence)
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> BOOL D3D11DeviceX<ABI>::IsResourcePending(gfx::ID3D11Resource<ABI> *pResource)
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePlacementBuffer(D3D11_BUFFER_DESC const *pDesc, void *pVirtualAddress,
gfx::ID3D11Buffer<ABI> **ppBuffer)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePlacementTexture1D(D3D11_TEXTURE1D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
void *pVirtualAddress, gfx::ID3D11Texture1D<ABI> **ppTexture1D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePlacementTexture2D(D3D11_TEXTURE2D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
void *pVirtualAddress, gfx::ID3D11Texture2D<ABI> **ppTexture2D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePlacementTexture3D(D3D11_TEXTURE3D_DESC const *pDesc, UINT TileModeIndex, UINT Pitch,
void *pVirtualAddress, gfx::ID3D11Texture3D<ABI> **ppTexture3D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> void D3D11DeviceX<ABI>::GetTimestamps(UINT64 *pGpuTimestamp, UINT64 *pCpuRdtscTimestamp)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateComputeContextX(gfx::D3D11_COMPUTE_CONTEXT_DESC const *pComputeContextDesc,
gfx::ID3D11ComputeContextX **ppComputeContext)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateSamplerStateX(gfx::D3D11X_SAMPLER_DESC const *pSamplerDesc,
gfx::ID3D11SamplerState<ABI> **ppSamplerState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDeferredContextX(UINT Flags, gfx::ID3D11DeviceContextX<ABI> **ppDeferredContext)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> void D3D11DeviceX<ABI>::GarbageCollect(UINT Flags)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreateDepthStencilStateX(D3D11_DEPTH_STENCIL_DESC const *pDepthStencilStateDesc,
gfx::ID3D11DepthStencilState<ABI> **ppDepthStencilState)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceX<ABI>::CreatePlacementRenderableTexture2D(D3D11_TEXTURE2D_DESC const *pDesc, UINT TileModeIndex,
UINT Pitch,
gfx::D3D11X_RENDERABLE_TEXTURE_ADDRESSES const *pAddresses,
gfx::ID3D11Texture2D<ABI> **ppTexture2D)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::GetDriverStatistics(UINT StructSize, gfx::D3D11X_DRIVER_STATISTICS *pStatistics)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::GetDescriptorSize(gfx::D3D11X_DESCRIPTOR_TYPE DescriptorType)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::ComposeShaderResourceView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_SHADER_RESOURCE_VIEW *pDescriptorSrv)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::ComposeUnorderedAccessView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_UNORDERED_ACCESS_VIEW *pDescriptorUav)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::ComposeConstantBufferView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_CONSTANT_BUFFER_VIEW *pDescriptorCb)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::ComposeVertexBufferView(gfx::D3D11X_DESCRIPTOR_RESOURCE const *pDescriptorResource,
gfx::D3D11X_RESOURCE_VIEW_DESC const *pViewDesc,
gfx::D3D11X_DESCRIPTOR_VERTEX_BUFFER_VIEW *pDescriptorVb)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::ComposeSamplerState(gfx::D3D11X_SAMPLER_STATE_DESC const *pSamplerDesc,
gfx::D3D11X_DESCRIPTOR_SAMPLER_STATE *pDescriptorSamplerState)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::PlaceSwapChainView(gfx::ID3D11Resource<ABI> *pSwapChainBuffer, gfx::ID3D11View<ABI> *pView)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DeviceX<ABI>::SetDebugFlags(UINT Flags)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> uint32_t D3D11DeviceX<ABI>::GetDebugFlags()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::SetHangCallbacks(gfx::D3D11XHANGBEGINCALLBACK pBeginCallback,
gfx::D3D11XHANGPRINTCALLBACK pPrintCallback,
gfx::D3D11XHANGDUMPCALLBACK pDumpCallback)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DeviceX<ABI>::ReportGpuHang(UINT Flags)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11DeviceX<ABI>::SetGpuMemoryPriority(UINT Priority)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
void D3D11DeviceX<ABI>::GetGpuHardwareConfiguration(gfx::D3D11X_GPU_HARDWARE_CONFIGURATION *pGpuHardwareConfiguration)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DeviceX<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

61
projects/WinDurango.D3D11X/src/ID3D11DeviceChild.cpp Normal file
View File

@@ -0,0 +1,61 @@
#include "ID3D11DeviceChild.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11DeviceChild<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11DeviceChild<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11DeviceChild<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11DeviceChild<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11DeviceChild<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceChild<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DeviceChild<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DeviceChild<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DeviceChild<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

1810
projects/WinDurango.D3D11X/src/ID3D11DeviceContext.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

453
projects/WinDurango.D3D11X/src/ID3D11Resource.cpp Normal file
View File

@@ -0,0 +1,453 @@
#include "ID3D11Resource.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11Resource<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11Resource<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11Resource<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11Resource<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11Resource<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Resource<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Resource<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Resource<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11Resource
//
template <abi_t ABI> void D3D11Resource<ABI>::GetType(D3D11_RESOURCE_DIMENSION *pDimension)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11Resource<ABI>::SetEvictionPriority(uint32_t EvictionPriority)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> uint32_t D3D11Resource<ABI>::GetEvictionPriority()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> void D3D11Resource<ABI>::GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Resource<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11Texture1D<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11Texture1D<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11Texture1D<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11Texture1D<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11Texture1D<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Texture1D<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Texture1D<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Texture1D<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11Resource
//
template <abi_t ABI> void D3D11Texture1D<ABI>::GetType(D3D11_RESOURCE_DIMENSION *pDimension)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11Texture1D<ABI>::SetEvictionPriority(uint32_t EvictionPriority)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> uint32_t D3D11Texture1D<ABI>::GetEvictionPriority()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> void D3D11Texture1D<ABI>::GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc)
{
IMPLEMENT_STUB();
}
//
// ID3D11Texture1D
//
template <abi_t ABI> void D3D11Texture1D<ABI>::GetDesc(D3D11_TEXTURE1D_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Texture1D<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11Texture2D<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11Texture2D<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11Texture2D<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11Texture2D<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11Texture2D<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Texture2D<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Texture2D<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Texture2D<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11Resource
//
template <abi_t ABI> void D3D11Texture2D<ABI>::GetType(D3D11_RESOURCE_DIMENSION *pDimension)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11Texture2D<ABI>::SetEvictionPriority(uint32_t EvictionPriority)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> uint32_t D3D11Texture2D<ABI>::GetEvictionPriority()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> void D3D11Texture2D<ABI>::GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc)
{
IMPLEMENT_STUB();
}
//
// ID3D11Texture2D
//
template <abi_t ABI> void D3D11Texture2D<ABI>::GetDesc(D3D11_TEXTURE2D_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Texture2D<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11Texture3D<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11Texture3D<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11Texture3D<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11Texture3D<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11Texture3D<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Texture3D<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Texture3D<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Texture3D<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11Resource
//
template <abi_t ABI> void D3D11Texture3D<ABI>::GetType(D3D11_RESOURCE_DIMENSION *pDimension)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11Texture3D<ABI>::SetEvictionPriority(uint32_t EvictionPriority)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> uint32_t D3D11Texture3D<ABI>::GetEvictionPriority()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> void D3D11Texture3D<ABI>::GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc)
{
IMPLEMENT_STUB();
}
//
// ID3D11Texture3D
//
template <abi_t ABI> void D3D11Texture3D<ABI>::GetDesc(D3D11_TEXTURE3D_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Texture3D<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11Buffer<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11Buffer<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11Buffer<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11Buffer<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11Buffer<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Buffer<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11Buffer<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11Buffer<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11Resource
//
template <abi_t ABI> void D3D11Buffer<ABI>::GetType(D3D11_RESOURCE_DIMENSION *pDimension)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11Buffer<ABI>::SetEvictionPriority(uint32_t EvictionPriority)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> uint32_t D3D11Buffer<ABI>::GetEvictionPriority()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> void D3D11Buffer<ABI>::GetDescriptor(gfx::D3D11X_DESCRIPTOR_RESOURCE *pDesc)
{
IMPLEMENT_STUB();
}
//
// ID3D11Buffer
//
template <abi_t ABI> void D3D11Buffer<ABI>::GetDesc(D3D11_TEXTURE1D_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11Buffer<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

368
projects/WinDurango.D3D11X/src/ID3D11Shader.cpp Normal file
View File

@@ -0,0 +1,368 @@
#include "ID3D11Shader.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11VertexShader<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11VertexShader<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11VertexShader<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11VertexShader<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11VertexShader<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11VertexShader<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11VertexShader<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11VertexShader<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11VertexShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11PixelShader<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11PixelShader<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11PixelShader<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11PixelShader<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11PixelShader<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11PixelShader<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11PixelShader<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11PixelShader<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11PixelShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11ComputeShader<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11ComputeShader<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11ComputeShader<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11ComputeShader<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11ComputeShader<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11ComputeShader<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11ComputeShader<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11ComputeShader<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11ComputeShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11GeometryShader<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11GeometryShader<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11GeometryShader<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11GeometryShader<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11GeometryShader<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11GeometryShader<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11GeometryShader<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11GeometryShader<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11GeometryShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11HullShader<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11HullShader<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11HullShader<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11HullShader<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11HullShader<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11HullShader<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11HullShader<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11HullShader<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11HullShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11DomainShader<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11DomainShader<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11DomainShader<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11DomainShader<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11DomainShader<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DomainShader<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11DomainShader<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DomainShader<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DomainShader<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

290
projects/WinDurango.D3D11X/src/ID3D11State.cpp Normal file
View File

@@ -0,0 +1,290 @@
#include "ID3D11State.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11SamplerState<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11SamplerState<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11SamplerState<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11SamplerState<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11SamplerState<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11SamplerState<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11SamplerState<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11SamplerState<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11SamplerState
//
template <abi_t ABI> void D3D11SamplerState<ABI>::GetDesc(D3D11_SAMPLER_DESC *pDesc)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11SamplerState<ABI>::GetDescX(gfx::D3D11X_SAMPLER_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11SamplerState<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11RasterizerState<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11RasterizerState<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11RasterizerState<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11RasterizerState<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11RasterizerState<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11RasterizerState<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11RasterizerState<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11RasterizerState<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11RasterizerState
//
template <abi_t ABI> void D3D11RasterizerState<ABI>::GetDesc(D3D11_RASTERIZER_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11RasterizerState<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11BlendState<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11BlendState<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11BlendState<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11BlendState<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11BlendState<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11BlendState<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11BlendState<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11BlendState<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11BlendState
//
template <abi_t ABI> void D3D11BlendState<ABI>::GetDesc(D3D11_BLEND_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11BlendState<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11DepthStencilState<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11DepthStencilState<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11DepthStencilState<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11DepthStencilState<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DepthStencilState<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DepthStencilState<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DepthStencilState<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DepthStencilState<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11DepthStencilState
//
template <abi_t ABI> void D3D11DepthStencilState<ABI>::GetDesc(D3D11_DEPTH_STENCIL_DESC *pDesc)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11DepthStencilState<ABI>::GetDescX(D3D11_DEPTH_STENCIL_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DepthStencilState<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

394
projects/WinDurango.D3D11X/src/ID3D11View.cpp Normal file
View File

@@ -0,0 +1,394 @@
#include "ID3D11View.h"
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11View<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11View<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11View<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11View<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> HRESULT D3D11View<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11View<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> HRESULT D3D11View<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11View<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid, xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11View
//
template <abi_t ABI> void D3D11View<ABI>::GetResource(gfx::ID3D11Resource<ABI> **ppResource)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11View<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11ShaderResourceView<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11ShaderResourceView<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11ShaderResourceView<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11ShaderResourceView<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11ShaderResourceView<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11ShaderResourceView<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11ShaderResourceView<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11ShaderResourceView<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11View
//
template <abi_t ABI> void D3D11ShaderResourceView<ABI>::GetResource(gfx::ID3D11Resource<ABI> **ppResource)
{
IMPLEMENT_STUB();
}
//
// ID3D11ShaderResourceView
//
template <abi_t ABI> void D3D11ShaderResourceView<ABI>::GetDesc(D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> void D3D11ShaderResourceView<ABI>::GetFormatX(gfx::D3D11X_SRV_FORMAT* pFormatX)
{
IMPLEMENT_STUB();
}
template <abi_t ABI> int32_t D3D11ShaderResourceView<ABI>::SetFormatX(gfx::D3D11X_SRV_FORMAT const *pFormatX)
{
IMPLEMENT_STUB();
return {};
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11ShaderResourceView<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11RenderTargetView<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11RenderTargetView<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11RenderTargetView<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11RenderTargetView<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11RenderTargetView<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11RenderTargetView<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11RenderTargetView<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11RenderTargetView<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11View
//
template <abi_t ABI> void D3D11RenderTargetView<ABI>::GetResource(gfx::ID3D11Resource<ABI> **ppResource)
{
IMPLEMENT_STUB();
}
//
// ID3D11RenderTargetView
//
template <abi_t ABI> void D3D11RenderTargetView<ABI>::GetDesc(D3D11_RENDER_TARGET_VIEW_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11RenderTargetView<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11DepthStencilView<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11DepthStencilView<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11DepthStencilView<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11DepthStencilView<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11DepthStencilView<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DepthStencilView<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DepthStencilView<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11DepthStencilView<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11View
//
template <abi_t ABI> void D3D11DepthStencilView<ABI>::GetResource(gfx::ID3D11Resource<ABI> **ppResource)
{
IMPLEMENT_STUB();
}
//
// ID3D11DepthStencilView
//
template <abi_t ABI> void D3D11DepthStencilView<ABI>::GetDesc(D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11DepthStencilView<ABI>
D3D11_DECLARE_ABI_TEMPLATES();
//
// IUnknown
//
template <abi_t ABI> HRESULT D3D11UnorderedAccessView<ABI>::QueryInterface(REFIID riid, void **ppvObject)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI> ULONG D3D11UnorderedAccessView<ABI>::AddRef()
{
IMPLEMENT_STUB();
return {};
}
template <abi_t ABI> ULONG D3D11UnorderedAccessView<ABI>::Release()
{
IMPLEMENT_STUB();
return {};
}
//
// ID3D11DeviceChild
//
template <abi_t ABI> void D3D11UnorderedAccessView<ABI>::GetDevice(gfx::ID3D11Device<ABI> **ppDevice)
{
IMPLEMENT_STUB();
}
template <abi_t ABI>
HRESULT D3D11UnorderedAccessView<ABI>::GetPrivateData(_GUID const &guid, uint32_t *pDataSize, void *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11UnorderedAccessView<ABI>::SetPrivateData(_GUID const &guid, uint32_t DataSize, void const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11UnorderedAccessView<ABI>::SetPrivateDataInterface(_GUID const &guid, IUnknown const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
template <abi_t ABI>
HRESULT D3D11UnorderedAccessView<ABI>::SetPrivateDataInterfaceGraphics(_GUID const &guid,
xbox::IGraphicsUnknown<ABI> const *pData)
{
IMPLEMENT_STUB();
return E_NOTIMPL;
}
//
// ID3D11View
//
template <abi_t ABI> void D3D11UnorderedAccessView<ABI>::GetResource(gfx::ID3D11Resource<ABI> **ppResource)
{
IMPLEMENT_STUB();
}
//
// ID3D11UnorderedAccessView
//
template <abi_t ABI> void D3D11UnorderedAccessView<ABI>::GetDesc(D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc)
{
IMPLEMENT_STUB();
}
#undef ABI_INTERFACE
#define ABI_INTERFACE(ABI) D3D11UnorderedAccessView<ABI>
D3D11_DECLARE_ABI_TEMPLATES();

9
projects/WinDurango.D3D11X/src/dllmain.cpp Normal file
View File

@@ -0,0 +1,9 @@
#include "d3d11.x.h"
BOOL WINAPI DllMain(HINSTANCE hinstDLL, // handle to DLL module
DWORD fdwReason, // reason for calling function
LPVOID lpvReserved) // reserved
{
GetCombaseVersion();
return TRUE;
}