1
0
mirror of https://github.com/doitsujin/dxvk.git synced 2024-12-14 18:23:52 +01:00
dxvk/src/d3d9/d3d9_device.h
2020-01-27 14:21:21 +01:00

1179 lines
38 KiB
C++

#pragma once
#include "../dxvk/dxvk_device.h"
#include "../dxvk/dxvk_cs.h"
#include "d3d9_include.h"
#include "d3d9_cursor.h"
#include "d3d9_format.h"
#include "d3d9_multithread.h"
#include "d3d9_adapter.h"
#include "d3d9_constant_set.h"
#include "d3d9_state.h"
#include "d3d9_options.h"
#include "../dxso/dxso_module.h"
#include "../dxso/dxso_util.h"
#include "../dxso/dxso_options.h"
#include "../dxso/dxso_modinfo.h"
#include "d3d9_sampler.h"
#include "d3d9_fixed_function.h"
#include "d3d9_swvp_emu.h"
#include "d3d9_shader_permutations.h"
#include <vector>
#include <type_traits>
#include <unordered_map>
namespace dxvk {
class D3D9InterfaceEx;
class D3D9SwapChainEx;
class D3D9CommonTexture;
class D3D9CommonBuffer;
class D3D9CommonShader;
class D3D9ShaderModuleSet;
class D3D9Initializer;
class D3D9Query;
class D3D9StateBlock;
class D3D9FormatHelper;
enum class D3D9DeviceFlag : uint32_t {
DirtyFramebuffer,
DirtyClipPlanes,
DirtyDepthStencilState,
DirtyBlendState,
DirtyRasterizerState,
DirtyDepthBias,
DirtyAlphaTestState,
DirtyInputLayout,
DirtyViewportScissor,
DirtyMultiSampleState,
DirtyFogState,
DirtyFogColor,
DirtyFogDensity,
DirtyFogScale,
DirtyFogEnd,
DirtyFFVertexData,
DirtyFFVertexBlend,
DirtyFFVertexShader,
DirtyFFPixelShader,
DirtyFFViewport,
DirtyFFPixelData,
DirtyProgVertexShader,
DirtySharedPixelShaderData,
UpDirtiedVertices,
UpDirtiedIndices,
ValidSampleMask,
DirtyDepthBounds,
DirtyPointScale,
};
using D3D9DeviceFlags = Flags<D3D9DeviceFlag>;
struct D3D9DrawInfo {
uint32_t vertexCount;
uint32_t instanceCount;
};
struct D3D9SamplerPair {
Rc<DxvkSampler> color;
Rc<DxvkSampler> depth;
};
struct D3D9UPBufferSlice {
DxvkBufferSlice slice = {};
void* mapPtr = nullptr;
};
class D3D9DeviceEx final : public ComObjectClamp<IDirect3DDevice9Ex> {
constexpr static uint32_t DefaultFrameLatency = 3;
constexpr static uint32_t MaxFrameLatency = 20;
constexpr static uint32_t MinFlushIntervalUs = 750;
constexpr static uint32_t IncFlushIntervalUs = 250;
constexpr static uint32_t MaxPendingSubmits = 6;
constexpr static uint32_t NullStreamIdx = caps::MaxStreams;
friend class D3D9SwapChainEx;
public:
D3D9DeviceEx(
D3D9InterfaceEx* pParent,
D3D9Adapter* pAdapter,
D3DDEVTYPE DeviceType,
HWND hFocusWindow,
DWORD BehaviorFlags,
Rc<DxvkDevice> dxvkDevice);
~D3D9DeviceEx();
HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);
HRESULT STDMETHODCALLTYPE TestCooperativeLevel();
UINT STDMETHODCALLTYPE GetAvailableTextureMem();
HRESULT STDMETHODCALLTYPE EvictManagedResources();
HRESULT STDMETHODCALLTYPE GetDirect3D(IDirect3D9** ppD3D9);
HRESULT STDMETHODCALLTYPE GetDeviceCaps(D3DCAPS9* pCaps);
HRESULT STDMETHODCALLTYPE GetDisplayMode(UINT iSwapChain, D3DDISPLAYMODE* pMode);
HRESULT STDMETHODCALLTYPE GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters);
HRESULT STDMETHODCALLTYPE SetCursorProperties(
UINT XHotSpot,
UINT YHotSpot,
IDirect3DSurface9* pCursorBitmap);
void STDMETHODCALLTYPE SetCursorPosition(int X, int Y, DWORD Flags);
BOOL STDMETHODCALLTYPE ShowCursor(BOOL bShow);
HRESULT STDMETHODCALLTYPE CreateAdditionalSwapChain(
D3DPRESENT_PARAMETERS* pPresentationParameters,
IDirect3DSwapChain9** ppSwapChain);
HRESULT STDMETHODCALLTYPE GetSwapChain(UINT iSwapChain, IDirect3DSwapChain9** pSwapChain);
UINT STDMETHODCALLTYPE GetNumberOfSwapChains();
HRESULT STDMETHODCALLTYPE Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
HRESULT STDMETHODCALLTYPE Present(
const RECT* pSourceRect,
const RECT* pDestRect, HWND hDestWindowOverride,
const RGNDATA* pDirtyRegion);
HRESULT STDMETHODCALLTYPE GetBackBuffer(
UINT iSwapChain,
UINT iBackBuffer,
D3DBACKBUFFER_TYPE Type,
IDirect3DSurface9** ppBackBuffer);
HRESULT STDMETHODCALLTYPE GetRasterStatus(UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus);
HRESULT STDMETHODCALLTYPE SetDialogBoxMode(BOOL bEnableDialogs);
void STDMETHODCALLTYPE SetGammaRamp(
UINT iSwapChain,
DWORD Flags,
const D3DGAMMARAMP* pRamp);
void STDMETHODCALLTYPE GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp);
HRESULT STDMETHODCALLTYPE CreateTexture(
UINT Width,
UINT Height,
UINT Levels,
DWORD Usage,
D3DFORMAT Format,
D3DPOOL Pool,
IDirect3DTexture9** ppTexture,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE CreateVolumeTexture(
UINT Width,
UINT Height,
UINT Depth,
UINT Levels,
DWORD Usage,
D3DFORMAT Format,
D3DPOOL Pool,
IDirect3DVolumeTexture9** ppVolumeTexture,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE CreateCubeTexture(
UINT EdgeLength,
UINT Levels,
DWORD Usage,
D3DFORMAT Format,
D3DPOOL Pool,
IDirect3DCubeTexture9** ppCubeTexture,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE CreateVertexBuffer(
UINT Length,
DWORD Usage,
DWORD FVF,
D3DPOOL Pool,
IDirect3DVertexBuffer9** ppVertexBuffer,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE CreateIndexBuffer(
UINT Length,
DWORD Usage,
D3DFORMAT Format,
D3DPOOL Pool,
IDirect3DIndexBuffer9** ppIndexBuffer,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE CreateRenderTarget(
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DMULTISAMPLE_TYPE MultiSample,
DWORD MultisampleQuality,
BOOL Lockable,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE CreateDepthStencilSurface(
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DMULTISAMPLE_TYPE MultiSample,
DWORD MultisampleQuality,
BOOL Discard,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE UpdateSurface(
IDirect3DSurface9* pSourceSurface,
const RECT* pSourceRect,
IDirect3DSurface9* pDestinationSurface,
const POINT* pDestPoint);
HRESULT STDMETHODCALLTYPE UpdateTexture(
IDirect3DBaseTexture9* pSourceTexture,
IDirect3DBaseTexture9* pDestinationTexture);
HRESULT STDMETHODCALLTYPE GetRenderTargetData(
IDirect3DSurface9* pRenderTarget,
IDirect3DSurface9* pDestSurface);
HRESULT STDMETHODCALLTYPE GetFrontBufferData(UINT iSwapChain, IDirect3DSurface9* pDestSurface);
HRESULT STDMETHODCALLTYPE StretchRect(
IDirect3DSurface9* pSourceSurface,
const RECT* pSourceRect,
IDirect3DSurface9* pDestSurface,
const RECT* pDestRect,
D3DTEXTUREFILTERTYPE Filter);
HRESULT STDMETHODCALLTYPE ColorFill(
IDirect3DSurface9* pSurface,
const RECT* pRect,
D3DCOLOR Color);
HRESULT STDMETHODCALLTYPE CreateOffscreenPlainSurface(
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DPOOL Pool,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle);
HRESULT STDMETHODCALLTYPE SetRenderTarget(
DWORD RenderTargetIndex,
IDirect3DSurface9* pRenderTarget);
HRESULT STDMETHODCALLTYPE GetRenderTarget(
DWORD RenderTargetIndex,
IDirect3DSurface9** ppRenderTarget);
HRESULT STDMETHODCALLTYPE SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);
HRESULT STDMETHODCALLTYPE GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);
HRESULT STDMETHODCALLTYPE BeginScene();
HRESULT STDMETHODCALLTYPE EndScene();
HRESULT STDMETHODCALLTYPE Clear(
DWORD Count,
const D3DRECT* pRects,
DWORD Flags,
D3DCOLOR Color,
float Z,
DWORD Stencil);
HRESULT STDMETHODCALLTYPE SetTransform(D3DTRANSFORMSTATETYPE State, const D3DMATRIX* pMatrix);
HRESULT STDMETHODCALLTYPE GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix);
HRESULT STDMETHODCALLTYPE MultiplyTransform(D3DTRANSFORMSTATETYPE TransformState, const D3DMATRIX* pMatrix);
HRESULT STDMETHODCALLTYPE SetViewport(const D3DVIEWPORT9* pViewport);
HRESULT STDMETHODCALLTYPE GetViewport(D3DVIEWPORT9* pViewport);
HRESULT STDMETHODCALLTYPE SetMaterial(const D3DMATERIAL9* pMaterial);
HRESULT STDMETHODCALLTYPE GetMaterial(D3DMATERIAL9* pMaterial);
HRESULT STDMETHODCALLTYPE SetLight(DWORD Index, const D3DLIGHT9* pLight);
HRESULT STDMETHODCALLTYPE GetLight(DWORD Index, D3DLIGHT9* pLight);
HRESULT STDMETHODCALLTYPE LightEnable(DWORD Index, BOOL Enable);
HRESULT STDMETHODCALLTYPE GetLightEnable(DWORD Index, BOOL* pEnable);
HRESULT STDMETHODCALLTYPE SetClipPlane(DWORD Index, const float* pPlane);
HRESULT STDMETHODCALLTYPE GetClipPlane(DWORD Index, float* pPlane);
HRESULT STDMETHODCALLTYPE SetRenderState(D3DRENDERSTATETYPE State, DWORD Value);
HRESULT STDMETHODCALLTYPE GetRenderState(D3DRENDERSTATETYPE State, DWORD* pValue);
HRESULT STDMETHODCALLTYPE CreateStateBlock(
D3DSTATEBLOCKTYPE Type,
IDirect3DStateBlock9** ppSB);
HRESULT STDMETHODCALLTYPE BeginStateBlock();
HRESULT STDMETHODCALLTYPE EndStateBlock(IDirect3DStateBlock9** ppSB);
HRESULT STDMETHODCALLTYPE SetClipStatus(const D3DCLIPSTATUS9* pClipStatus);
HRESULT STDMETHODCALLTYPE GetClipStatus(D3DCLIPSTATUS9* pClipStatus);
HRESULT STDMETHODCALLTYPE GetTexture(DWORD Stage, IDirect3DBaseTexture9** ppTexture);
HRESULT STDMETHODCALLTYPE SetTexture(DWORD Stage, IDirect3DBaseTexture9* pTexture);
HRESULT STDMETHODCALLTYPE GetTextureStageState(
DWORD Stage,
D3DTEXTURESTAGESTATETYPE Type,
DWORD* pValue);
HRESULT STDMETHODCALLTYPE SetTextureStageState(
DWORD Stage,
D3DTEXTURESTAGESTATETYPE Type,
DWORD Value);
HRESULT STDMETHODCALLTYPE GetSamplerState(
DWORD Sampler,
D3DSAMPLERSTATETYPE Type,
DWORD* pValue);
HRESULT STDMETHODCALLTYPE SetSamplerState(
DWORD Sampler,
D3DSAMPLERSTATETYPE Type,
DWORD Value);
HRESULT STDMETHODCALLTYPE ValidateDevice(DWORD* pNumPasses);
HRESULT STDMETHODCALLTYPE SetPaletteEntries(UINT PaletteNumber, const PALETTEENTRY* pEntries);
HRESULT STDMETHODCALLTYPE GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY* pEntries);
HRESULT STDMETHODCALLTYPE SetCurrentTexturePalette(UINT PaletteNumber);
HRESULT STDMETHODCALLTYPE GetCurrentTexturePalette(UINT *PaletteNumber);
HRESULT STDMETHODCALLTYPE SetScissorRect(const RECT* pRect);
HRESULT STDMETHODCALLTYPE GetScissorRect(RECT* pRect);
HRESULT STDMETHODCALLTYPE SetSoftwareVertexProcessing(BOOL bSoftware);
BOOL STDMETHODCALLTYPE GetSoftwareVertexProcessing();
HRESULT STDMETHODCALLTYPE SetNPatchMode(float nSegments);
float STDMETHODCALLTYPE GetNPatchMode();
HRESULT STDMETHODCALLTYPE DrawPrimitive(
D3DPRIMITIVETYPE PrimitiveType,
UINT StartVertex,
UINT PrimitiveCount);
HRESULT STDMETHODCALLTYPE DrawIndexedPrimitive(
D3DPRIMITIVETYPE PrimitiveType,
INT BaseVertexIndex,
UINT MinVertexIndex,
UINT NumVertices,
UINT StartIndex,
UINT PrimitiveCount);
HRESULT STDMETHODCALLTYPE DrawPrimitiveUP(
D3DPRIMITIVETYPE PrimitiveType,
UINT PrimitiveCount,
const void* pVertexStreamZeroData,
UINT VertexStreamZeroStride);
HRESULT STDMETHODCALLTYPE DrawIndexedPrimitiveUP(
D3DPRIMITIVETYPE PrimitiveType,
UINT MinVertexIndex,
UINT NumVertices,
UINT PrimitiveCount,
const void* pIndexData,
D3DFORMAT IndexDataFormat,
const void* pVertexStreamZeroData,
UINT VertexStreamZeroStride);
HRESULT STDMETHODCALLTYPE ProcessVertices(
UINT SrcStartIndex,
UINT DestIndex,
UINT VertexCount,
IDirect3DVertexBuffer9* pDestBuffer,
IDirect3DVertexDeclaration9* pVertexDecl,
DWORD Flags);
HRESULT STDMETHODCALLTYPE CreateVertexDeclaration(
const D3DVERTEXELEMENT9* pVertexElements,
IDirect3DVertexDeclaration9** ppDecl);
HRESULT STDMETHODCALLTYPE SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);
HRESULT STDMETHODCALLTYPE GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl);
HRESULT STDMETHODCALLTYPE SetFVF(DWORD FVF);
HRESULT STDMETHODCALLTYPE GetFVF(DWORD* pFVF);
HRESULT STDMETHODCALLTYPE CreateVertexShader(
const DWORD* pFunction,
IDirect3DVertexShader9** ppShader);
HRESULT STDMETHODCALLTYPE SetVertexShader(IDirect3DVertexShader9* pShader);
HRESULT STDMETHODCALLTYPE GetVertexShader(IDirect3DVertexShader9** ppShader);
HRESULT STDMETHODCALLTYPE SetVertexShaderConstantF(
UINT StartRegister,
const float* pConstantData,
UINT Vector4fCount);
HRESULT STDMETHODCALLTYPE GetVertexShaderConstantF(
UINT StartRegister,
float* pConstantData,
UINT Vector4fCount);
HRESULT STDMETHODCALLTYPE SetVertexShaderConstantI(
UINT StartRegister,
const int* pConstantData,
UINT Vector4iCount);
HRESULT STDMETHODCALLTYPE GetVertexShaderConstantI(
UINT StartRegister,
int* pConstantData,
UINT Vector4iCount);
HRESULT STDMETHODCALLTYPE SetVertexShaderConstantB(
UINT StartRegister,
const BOOL* pConstantData,
UINT BoolCount);
HRESULT STDMETHODCALLTYPE GetVertexShaderConstantB(
UINT StartRegister,
BOOL* pConstantData,
UINT BoolCount);
HRESULT STDMETHODCALLTYPE SetStreamSource(
UINT StreamNumber,
IDirect3DVertexBuffer9* pStreamData,
UINT OffsetInBytes,
UINT Stride);
HRESULT STDMETHODCALLTYPE GetStreamSource(
UINT StreamNumber,
IDirect3DVertexBuffer9** ppStreamData,
UINT* pOffsetInBytes,
UINT* pStride);
HRESULT STDMETHODCALLTYPE SetStreamSourceFreq(UINT StreamNumber, UINT Setting);
HRESULT STDMETHODCALLTYPE GetStreamSourceFreq(UINT StreamNumber, UINT* pSetting);
HRESULT STDMETHODCALLTYPE SetIndices(IDirect3DIndexBuffer9* pIndexData);
HRESULT STDMETHODCALLTYPE GetIndices(IDirect3DIndexBuffer9** ppIndexData);
HRESULT STDMETHODCALLTYPE CreatePixelShader(
const DWORD* pFunction,
IDirect3DPixelShader9** ppShader);
HRESULT STDMETHODCALLTYPE SetPixelShader(IDirect3DPixelShader9* pShader);
HRESULT STDMETHODCALLTYPE GetPixelShader(IDirect3DPixelShader9** ppShader);
HRESULT STDMETHODCALLTYPE SetPixelShaderConstantF(
UINT StartRegister,
const float* pConstantData,
UINT Vector4fCount);
HRESULT STDMETHODCALLTYPE GetPixelShaderConstantF(
UINT StartRegister,
float* pConstantData,
UINT Vector4fCount);
HRESULT STDMETHODCALLTYPE SetPixelShaderConstantI(
UINT StartRegister,
const int* pConstantData,
UINT Vector4iCount);
HRESULT STDMETHODCALLTYPE GetPixelShaderConstantI(
UINT StartRegister,
int* pConstantData,
UINT Vector4iCount);
HRESULT STDMETHODCALLTYPE SetPixelShaderConstantB(
UINT StartRegister,
const BOOL* pConstantData,
UINT BoolCount);
HRESULT STDMETHODCALLTYPE GetPixelShaderConstantB(
UINT StartRegister,
BOOL* pConstantData,
UINT BoolCount);
HRESULT STDMETHODCALLTYPE DrawRectPatch(
UINT Handle,
const float* pNumSegs,
const D3DRECTPATCH_INFO* pRectPatchInfo);
HRESULT STDMETHODCALLTYPE DrawTriPatch(
UINT Handle,
const float* pNumSegs,
const D3DTRIPATCH_INFO* pTriPatchInfo);
HRESULT STDMETHODCALLTYPE DeletePatch(UINT Handle);
HRESULT STDMETHODCALLTYPE CreateQuery(D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery);
// Ex Methods
HRESULT STDMETHODCALLTYPE SetConvolutionMonoKernel(
UINT width,
UINT height,
float* rows,
float* columns);
HRESULT STDMETHODCALLTYPE ComposeRects(
IDirect3DSurface9* pSrc,
IDirect3DSurface9* pDst,
IDirect3DVertexBuffer9* pSrcRectDescs,
UINT NumRects,
IDirect3DVertexBuffer9* pDstRectDescs,
D3DCOMPOSERECTSOP Operation,
int Xoffset,
int Yoffset);
HRESULT STDMETHODCALLTYPE GetGPUThreadPriority(INT* pPriority);
HRESULT STDMETHODCALLTYPE SetGPUThreadPriority(INT Priority);
HRESULT STDMETHODCALLTYPE WaitForVBlank(UINT iSwapChain);
HRESULT STDMETHODCALLTYPE CheckResourceResidency(IDirect3DResource9** pResourceArray, UINT32 NumResources);
HRESULT STDMETHODCALLTYPE SetMaximumFrameLatency(UINT MaxLatency);
HRESULT STDMETHODCALLTYPE GetMaximumFrameLatency(UINT* pMaxLatency);
HRESULT STDMETHODCALLTYPE CheckDeviceState(HWND hDestinationWindow);
HRESULT STDMETHODCALLTYPE PresentEx(
const RECT* pSourceRect,
const RECT* pDestRect,
HWND hDestWindowOverride,
const RGNDATA* pDirtyRegion,
DWORD dwFlags);
HRESULT STDMETHODCALLTYPE CreateRenderTargetEx(
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DMULTISAMPLE_TYPE MultiSample,
DWORD MultisampleQuality,
BOOL Lockable,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle,
DWORD Usage);
HRESULT STDMETHODCALLTYPE CreateOffscreenPlainSurfaceEx(
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DPOOL Pool,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle,
DWORD Usage);
HRESULT STDMETHODCALLTYPE CreateDepthStencilSurfaceEx(
UINT Width,
UINT Height,
D3DFORMAT Format,
D3DMULTISAMPLE_TYPE MultiSample,
DWORD MultisampleQuality,
BOOL Discard,
IDirect3DSurface9** ppSurface,
HANDLE* pSharedHandle,
DWORD Usage);
HRESULT STDMETHODCALLTYPE ResetEx(
D3DPRESENT_PARAMETERS* pPresentationParameters,
D3DDISPLAYMODEEX* pFullscreenDisplayMode);
HRESULT STDMETHODCALLTYPE GetDisplayModeEx(
UINT iSwapChain,
D3DDISPLAYMODEEX* pMode,
D3DDISPLAYROTATION* pRotation);
HRESULT STDMETHODCALLTYPE CreateAdditionalSwapChainEx(
D3DPRESENT_PARAMETERS* pPresentationParameters,
const D3DDISPLAYMODEEX* pFullscreenDisplayMode,
IDirect3DSwapChain9** ppSwapChain);
HRESULT SetStateSamplerState(
DWORD StateSampler,
D3DSAMPLERSTATETYPE Type,
DWORD Value);
HRESULT SetStateTexture(DWORD StateSampler, IDirect3DBaseTexture9* pTexture);
HRESULT SetStateTransform(uint32_t idx, const D3DMATRIX* pMatrix);
HRESULT SetStateTextureStageState(
DWORD Stage,
D3D9TextureStageStateTypes Type,
DWORD Value);
VkPipelineStageFlags GetEnabledShaderStages() const {
return m_dxvkDevice->getShaderPipelineStages();
}
static DxvkDeviceFeatures GetDeviceFeatures(const Rc<DxvkAdapter>& adapter);
bool SupportsSWVP();
bool IsExtended();
HWND GetWindow();
Rc<DxvkDevice> GetDXVKDevice() {
return m_dxvkDevice;
}
D3D9_VK_FORMAT_MAPPING LookupFormat(
D3D9Format Format) const;
DxvkFormatInfo UnsupportedFormatInfo(
D3D9Format Format) const;
bool WaitForResource(
const Rc<DxvkResource>& Resource,
DWORD MapFlags);
/**
* \brief Locks a subresource of an image
*
* \param [in] Subresource The subresource of the image to lock
* \param [out] pLockedBox The returned locked box of the image, containing data ptr and strides
* \param [in] pBox The region of the subresource to lock. This offsets the returned data ptr
* \param [in] Flags The D3DLOCK_* flags to lock the image with
* \returns \c D3D_OK if the parameters are valid or D3DERR_INVALIDCALL if it fails.
*/
HRESULT LockImage(
D3D9CommonTexture* pResource,
UINT Face,
UINT Mip,
D3DLOCKED_BOX* pLockedBox,
const D3DBOX* pBox,
DWORD Flags);
uint32_t CalcImageLockOffset(
uint32_t SlicePitch,
uint32_t RowPitch,
const DxvkFormatInfo* FormatInfo,
const D3DBOX* pBox);
/**
* \brief Unlocks a subresource of an image
*
* Passthrough to device unlock.
* \param [in] Subresource The subresource of the image to unlock
* \returns \c D3D_OK if the parameters are valid or D3DERR_INVALIDCALL if it fails.
*/
HRESULT UnlockImage(
D3D9CommonTexture* pResource,
UINT Face,
UINT MipLevel);
HRESULT FlushImage(
D3D9CommonTexture* pResource,
UINT Subresource);
void GenerateMips(
D3D9CommonTexture* pResource);
HRESULT LockBuffer(
D3D9CommonBuffer* pResource,
UINT OffsetToLock,
UINT SizeToLock,
void** ppbData,
DWORD Flags);
HRESULT FlushBuffer(
D3D9CommonBuffer* pResource);
HRESULT UnlockBuffer(
D3D9CommonBuffer* pResource);
void SetupFPU();
int64_t DetermineInitialTextureMemory();
void CreateConstantBuffers();
void SynchronizeCsThread();
void Flush();
D3D9ShaderMasks GetShaderMasks();
void UpdateActiveRTs(uint32_t index);
void UpdateActiveRTTextures(uint32_t index);
void UpdateActiveHazards();
void MarkRenderHazards();
template <bool Points>
void UpdatePointMode();
void UpdateFog();
void BindFramebuffer();
void BindViewportAndScissor();
inline bool IsAlphaToCoverageEnabled() {
const bool alphaTest = m_state.renderStates[D3DRS_ALPHATESTENABLE] != 0;
return m_amdATOC || (m_nvATOC && alphaTest);
}
inline bool IsDepthBiasEnabled() {
const auto& rs = m_state.renderStates;
float depthBias = bit::cast<float>(rs[D3DRS_DEPTHBIAS]);
float slopeScaledDepthBias = bit::cast<float>(rs[D3DRS_SLOPESCALEDEPTHBIAS]);
return depthBias != 0.0f || slopeScaledDepthBias != 0.0f;
}
inline bool IsAlphaTestEnabled() {
return m_state.renderStates[D3DRS_ALPHATESTENABLE] && !IsAlphaToCoverageEnabled();
}
inline bool IsZTestEnabled() {
return m_state.renderStates[D3DRS_ZENABLE] && m_state.depthStencil != nullptr;
}
void BindMultiSampleState();
void BindBlendState();
void BindBlendFactor();
void BindDepthStencilState();
void BindDepthStencilRefrence();
void BindRasterizerState();
void BindDepthBias();
void BindAlphaTestState();
template <DxsoProgramType ShaderStage, typename HardwareLayoutType, typename SoftwareLayoutType, typename ShaderType>
inline void UploadHardwareConstantSet(void* pData, const SoftwareLayoutType& Src, const ShaderType& Shader);
template <typename SoftwareLayoutType, typename ShaderType>
inline void UploadSoftwareConstantSet(void* pData, const SoftwareLayoutType& Src, const D3D9ConstantLayout& Layout, const ShaderType& Shader);
template <DxsoProgramType ShaderStage, typename HardwareLayoutType, typename SoftwareLayoutType, typename ShaderType>
inline void UploadConstantSet(const SoftwareLayoutType& Src, const D3D9ConstantLayout& Layout, const ShaderType& Shader);
template <DxsoProgramType ShaderStage>
void UploadConstants();
void UpdateClipPlanes();
template <uint32_t Offset, uint32_t Length>
void UpdatePushConstant(const void* pData);
template <D3D9RenderStateItem Item>
void UpdatePushConstant();
void BindSampler(DWORD Sampler);
void BindTexture(DWORD SamplerSampler);
void UndirtySamplers();
void MarkSamplersDirty();
D3D9DrawInfo GenerateDrawInfo(
D3DPRIMITIVETYPE PrimitiveType,
UINT PrimitiveCount,
UINT InstanceCount);
uint32_t GetInstanceCount() const;
void PrepareDraw(D3DPRIMITIVETYPE PrimitiveType, bool up = false);
template <DxsoProgramType ShaderStage>
void BindShader(
const D3D9CommonShader* pShaderModule,
D3D9ShaderPermutation Permutation);
void BindInputLayout();
void BindVertexBuffer(
UINT Slot,
D3D9VertexBuffer* pBuffer,
UINT Offset,
UINT Stride);
void BindIndices();
D3D9DeviceLock LockDevice() {
return m_multithread.AcquireLock();
}
const D3D9Options* GetOptions() const {
return &m_d3d9Options;
}
Direct3DState9* GetRawState() {
return &m_state;
}
void Begin(D3D9Query* pQuery);
void End(D3D9Query* pQuery);
void SetVertexBoolBitfield(uint32_t idx, uint32_t mask, uint32_t bits);
void SetPixelBoolBitfield (uint32_t idx, uint32_t mask, uint32_t bits);
void FlushImplicit(BOOL StrongHint);
bool ChangeReportedMemory(int64_t delta) {
if (IsExtended())
return true;
int64_t availableMemory = m_availableMemory.fetch_add(delta);
return !m_d3d9Options.memoryTrackTest || availableMemory >= delta;
}
void ResolveZ();
void TransitionImage(D3D9CommonTexture* pResource, VkImageLayout NewLayout);
void TransformImage(
D3D9CommonTexture* pResource,
const VkImageSubresourceRange* pSubresources,
VkImageLayout OldLayout,
VkImageLayout NewLayout);
const D3D9ConstantLayout& GetVertexConstantLayout() { return m_vsLayout; }
const D3D9ConstantLayout& GetPixelConstantLayout() { return m_psLayout; }
HRESULT ResetState(D3DPRESENT_PARAMETERS* pPresentationParameters);
HRESULT ResetSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode);
HRESULT InitialReset(D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode);
UINT GetSamplerCount() const {
return m_samplerCount.load();
}
private:
D3D9DeviceFlags m_flags;
uint32_t m_dirtySamplerStates = 0;
D3D9Adapter* m_adapter;
Rc<DxvkDevice> m_dxvkDevice;
Rc<DxvkDataBuffer> m_updateBuffer;
DxvkCsChunkPool m_csChunkPool;
dxvk::high_resolution_clock::time_point m_lastFlush
= dxvk::high_resolution_clock::now();
DxvkCsThread m_csThread;
bool m_csIsBusy = false;
uint32_t m_frameLatency = DefaultFrameLatency;
D3D9Initializer* m_initializer = nullptr;
D3D9FormatHelper* m_converter = nullptr;
DxvkCsChunkRef m_csChunk;
D3D9FFShaderModuleSet m_ffModules;
D3D9SWVPEmulator m_swvpEmulator;
DxvkCsChunkRef AllocCsChunk() {
DxvkCsChunk* chunk = m_csChunkPool.allocChunk(DxvkCsChunkFlag::SingleUse);
return DxvkCsChunkRef(chunk, &m_csChunkPool);
}
template<typename Cmd>
void EmitCs(Cmd&& command) {
if (unlikely(!m_csChunk->push(command))) {
EmitCsChunk(std::move(m_csChunk));
m_csChunk = AllocCsChunk();
m_csChunk->push(command);
}
}
void EmitCsChunk(DxvkCsChunkRef&& chunk);
void FlushCsChunk() {
if (likely(!m_csChunk->empty())) {
EmitCsChunk(std::move(m_csChunk));
m_csChunk = AllocCsChunk();
}
}
bool CanSWVP() {
return m_behaviorFlags & (D3DCREATE_MIXED_VERTEXPROCESSING | D3DCREATE_SOFTWARE_VERTEXPROCESSING);
}
inline constexpr D3D9ShaderPermutation GetVertexShaderPermutation() {
return D3D9ShaderPermutations::None;
}
inline D3D9ShaderPermutation GetPixelShaderPermutation() {
if (unlikely(m_state.renderStates[D3DRS_SHADEMODE] == D3DSHADE_FLAT))
return D3D9ShaderPermutations::FlatShade;
return D3D9ShaderPermutations::None;
}
Com<D3D9InterfaceEx> m_parent;
D3DDEVTYPE m_deviceType;
HWND m_window;
DWORD m_behaviorFlags;
Direct3DState9 m_state;
Com<D3D9StateBlock> m_recorder;
D3D9Multithread m_multithread;
Rc<D3D9ShaderModuleSet> m_shaderModules;
D3D9ConstantSets m_consts[DxsoProgramTypes::Count];
Rc<DxvkBuffer> m_vsClipPlanes;
Rc<DxvkBuffer> m_vsFixedFunction;
Rc<DxvkBuffer> m_vsVertexBlend;
Rc<DxvkBuffer> m_psFixedFunction;
Rc<DxvkBuffer> m_psShared;
D3D9UPBufferSlice m_upBuffer;
const D3D9Options m_d3d9Options;
const DxsoOptions m_dxsoOptions;
BOOL m_isSWVP;
D3DPRESENT_PARAMETERS m_presentParams;
D3D9Cursor m_cursor;
Com<D3D9Surface, false> m_autoDepthStencil;
std::vector<
Com<D3D9SwapChainEx,
false>> m_swapchains;
std::unordered_map<
D3D9SamplerKey,
D3D9SamplerPair,
D3D9SamplerKeyHash,
D3D9SamplerKeyEq> m_samplers;
std::unordered_map<
DWORD,
Com<D3D9VertexDecl>> m_fvfTable;
D3D9InputAssemblyState m_iaState;
uint32_t m_instancedData = 0;
uint32_t m_lastSamplerTypeBitfield = 0;
uint32_t m_samplerTypeBitfield = 0;
uint32_t m_lastProjectionBitfield = 0;
uint32_t m_projectionBitfield = 0;
uint32_t m_lastBoolSpecConstantVertex = 0;
uint32_t m_lastBoolSpecConstantPixel = 0;
uint32_t m_lastPointMode = 0;
uint32_t m_activeRTs = 0;
uint32_t m_activeRTTextures = 0;
uint32_t m_activeHazards = 0;
uint32_t m_alphaSwizzleRTs = 0;
D3D9ViewportInfo m_viewportInfo;
std::atomic<int64_t> m_availableMemory = 0;
std::atomic<int32_t> m_samplerCount = 0;
bool m_amdATOC = false;
bool m_nvATOC = false;
bool m_ffZTest = false;
float m_depthBiasScale = 0.0f;
D3D9ConstantLayout m_vsLayout;
D3D9ConstantLayout m_psLayout;
void DetermineConstantLayouts(bool canSWVP);
D3D9UPBufferSlice AllocUpBuffer(VkDeviceSize size);
D3D9SwapChainEx* GetInternalSwapchain(UINT index);
bool ShouldRecord();
HRESULT CreateShaderModule(
D3D9CommonShader* pShaderModule,
VkShaderStageFlagBits ShaderStage,
const DWORD* pShaderBytecode,
const DxsoModuleInfo* pModuleInfo);
// So we don't do OOB.
template <DxsoProgramType ProgramType,
D3D9ConstantType ConstantType>
inline static constexpr uint32_t DetermineSoftwareRegCount() {
constexpr bool isVS = ProgramType == DxsoProgramType::VertexShader;
switch (ConstantType) {
default:
case D3D9ConstantType::Float: return isVS ? caps::MaxFloatConstantsSoftware : caps::MaxFloatConstantsPS;
case D3D9ConstantType::Int: return isVS ? caps::MaxOtherConstantsSoftware : caps::MaxOtherConstants;
case D3D9ConstantType::Bool: return isVS ? caps::MaxOtherConstantsSoftware : caps::MaxOtherConstants;
}
}
// So we don't copy more than we need.
template <DxsoProgramType ProgramType,
D3D9ConstantType ConstantType>
inline uint32_t DetermineHardwareRegCount() const {
const auto& layout = ProgramType == DxsoProgramType::VertexShader
? m_vsLayout : m_psLayout;
switch (ConstantType) {
default:
case D3D9ConstantType::Float: return layout.floatCount;
case D3D9ConstantType::Int: return layout.intCount;
case D3D9ConstantType::Bool: return layout.boolCount;
}
}
inline uint32_t GetFrameLatency() {
return m_frameLatency;
}
template <
DxsoProgramType ProgramType,
D3D9ConstantType ConstantType,
typename T>
HRESULT SetShaderConstants(
UINT StartRegister,
const T* pConstantData,
UINT Count);
template <
DxsoProgramType ProgramType,
D3D9ConstantType ConstantType,
typename T>
HRESULT GetShaderConstants(
UINT StartRegister,
T* pConstantData,
UINT Count) {
auto GetHelper = [&] (const auto& set) {
const uint32_t regCountHardware = DetermineHardwareRegCount<ProgramType, ConstantType>();
constexpr uint32_t regCountSoftware = DetermineSoftwareRegCount<ProgramType, ConstantType>();
if (StartRegister + Count > regCountSoftware)
return D3DERR_INVALIDCALL;
Count = UINT(
std::max<INT>(
std::clamp<INT>(Count + StartRegister, 0, regCountHardware) - INT(StartRegister),
0));
if (Count == 0)
return D3D_OK;
if (pConstantData == nullptr)
return D3DERR_INVALIDCALL;
if constexpr (ConstantType == D3D9ConstantType::Float) {
auto begin = &set.fConsts[StartRegister];
auto end = &begin[Count];
std::copy(begin, end, reinterpret_cast<Vector4*>(pConstantData));
}
else if constexpr (ConstantType == D3D9ConstantType::Int) {
auto begin = &set.iConsts[StartRegister];
auto end = &begin[Count];
std::copy(begin, end, reinterpret_cast<Vector4i*>(pConstantData));
}
else {
for (uint32_t i = 0; i < Count; i++) {
const uint32_t constantIdx = StartRegister + i;
const uint32_t arrayIdx = constantIdx / 32;
const uint32_t bitIdx = constantIdx % 32;
const uint32_t bit = (1u << bitIdx);
bool constValue = set.bConsts[arrayIdx] & bit;
pConstantData[i] = constValue ? TRUE : FALSE;
}
}
return D3D_OK;
};
return ProgramType == DxsoProgramTypes::VertexShader
? GetHelper(m_state.vsConsts)
: GetHelper(m_state.psConsts);
}
void UpdateFixedFunctionVS();
void UpdateFixedFunctionPS();
void ApplyPrimitiveType(
DxvkContext* pContext,
D3DPRIMITIVETYPE PrimType);
bool UseProgrammableVS();
bool UseProgrammablePS();
void UpdateBoolSpecConstantVertex(uint32_t value);
void UpdateBoolSpecConstantPixel(uint32_t value);
void UpdateSamplerSpecConsant(uint32_t value);
void UpdateProjectionSpecConstant(uint32_t value);
};
}