From ca9404ec6fb91c6745033c59224f6664699b6b14 Mon Sep 17 00:00:00 2001 From: narzoul Date: Mon, 18 May 2020 00:52:28 +0200 Subject: [PATCH] Suppress flushes from execute buffers Mitigates performance issues in Rowan's Mig Alley (issue #12). --- DDrawCompat/Common/Log.h | 2 + DDrawCompat/D3dDdi/Device.cpp | 155 +++++++------ DDrawCompat/D3dDdi/Device.h | 44 ++-- DDrawCompat/D3dDdi/DeviceFuncs.cpp | 15 +- DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h | 2 + DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h | 2 + DDrawCompat/D3dDdi/Log/DeviceFuncsLog.cpp | 218 ++++++++++++++++++- DDrawCompat/D3dDdi/Log/DeviceFuncsLog.h | 6 +- DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h | 2 + DDrawCompat/DDrawCompat.vcxproj | 2 + DDrawCompat/DDrawCompat.vcxproj.filters | 6 + DDrawCompat/Direct3d/Direct3dDevice.cpp | 33 ++- DDrawCompat/Gdi/Dc.cpp | 3 +- 13 files changed, 383 insertions(+), 107 deletions(-) diff --git a/DDrawCompat/Common/Log.h b/DDrawCompat/Common/Log.h index bb08e7e..c899d0d 100644 --- a/DDrawCompat/Common/Log.h +++ b/DDrawCompat/Common/Log.h @@ -32,6 +32,8 @@ } \ } +#define LOG_CONST_CASE(constant) case constant: return os << #constant; + std::ostream& operator<<(std::ostream& os, std::nullptr_t); std::ostream& operator<<(std::ostream& os, const char* str); std::ostream& operator<<(std::ostream& os, const unsigned char* data); diff --git a/DDrawCompat/D3dDdi/Device.cpp b/DDrawCompat/D3dDdi/Device.cpp index 5ec9097..f83fbaf 100644 --- a/DDrawCompat/D3dDdi/Device.cpp +++ b/DDrawCompat/D3dDdi/Device.cpp @@ -29,34 +29,34 @@ namespace D3dDdi { } - HRESULT Device::blt(const D3DDDIARG_BLT& data) + HRESULT Device::blt(const D3DDDIARG_BLT* data) { - auto it = m_resources.find(data.hDstResource); + auto it = m_resources.find(data->hDstResource); if (it != m_resources.end()) { - return it->second.blt(data); + return it->second.blt(*data); } - prepareForRendering(data.hSrcResource, data.SrcSubResourceIndex, true); - return m_origVtable.pfnBlt(m_device, &data); + prepareForRendering(data->hSrcResource, data->SrcSubResourceIndex, true); + return m_origVtable.pfnBlt(m_device, data); } - HRESULT Device::clear(const D3DDDIARG_CLEAR& data, UINT numRect, const RECT* rect) + HRESULT Device::clear(const D3DDDIARG_CLEAR* data, UINT numRect, const RECT* rect) { - if (data.Flags & D3DCLEAR_TARGET) + if (data->Flags & D3DCLEAR_TARGET) { prepareForRendering(); } - return m_origVtable.pfnClear(m_device, &data, numRect, rect); + return m_origVtable.pfnClear(m_device, data, numRect, rect); } - HRESULT Device::colorFill(const D3DDDIARG_COLORFILL& data) + HRESULT Device::colorFill(const D3DDDIARG_COLORFILL* data) { - auto it = m_resources.find(data.hResource); + auto it = m_resources.find(data->hResource); if (it != m_resources.end()) { - return it->second.colorFill(data); + return it->second.colorFill(*data); } - return m_origVtable.pfnColorFill(m_device, &data); + return m_origVtable.pfnColorFill(m_device, data); } template @@ -74,14 +74,14 @@ namespace D3dDdi } } - HRESULT Device::createResource(D3DDDIARG_CREATERESOURCE& data) + HRESULT Device::createResource(D3DDDIARG_CREATERESOURCE* data) { - return createResourceImpl(data); + return createResourceImpl(*data); } - HRESULT Device::createResource2(D3DDDIARG_CREATERESOURCE2& data) + HRESULT Device::createResource2(D3DDDIARG_CREATERESOURCE2* data) { - return createResourceImpl(data); + return createResourceImpl(*data); } HRESULT Device::destroyResource(HANDLE resource) @@ -124,111 +124,129 @@ namespace D3dDdi return result; } - HRESULT Device::drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE& data) + HRESULT Device::drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE* data) { prepareForRendering(); - return m_origVtable.pfnDrawIndexedPrimitive(m_device, &data); + return m_origVtable.pfnDrawIndexedPrimitive(m_device, data); } - HRESULT Device::drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2& data, + HRESULT Device::drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2* data, UINT indicesSize, const void* indexBuffer, const UINT* flagBuffer) { prepareForRendering(); - return m_origVtable.pfnDrawIndexedPrimitive2(m_device, &data, indicesSize, indexBuffer, flagBuffer); + return m_origVtable.pfnDrawIndexedPrimitive2(m_device, data, indicesSize, indexBuffer, flagBuffer); } - HRESULT Device::drawPrimitive(const D3DDDIARG_DRAWPRIMITIVE& data, const UINT* flagBuffer) + HRESULT Device::drawPrimitive(const D3DDDIARG_DRAWPRIMITIVE* data, const UINT* flagBuffer) { if (m_streamSource && 0 != m_streamSourceData.Stride) { - m_streamSource->fixVertexData(m_streamSourceData.Offset + data.VStart * m_streamSourceData.Stride, - data.PrimitiveCount, m_streamSourceData.Stride); + m_streamSource->fixVertexData(m_streamSourceData.Offset + data->VStart * m_streamSourceData.Stride, + data->PrimitiveCount, m_streamSourceData.Stride); } prepareForRendering(); - return m_origVtable.pfnDrawPrimitive(m_device, &data, flagBuffer); + return m_origVtable.pfnDrawPrimitive(m_device, data, flagBuffer); } - HRESULT Device::drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2& data) + HRESULT Device::drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2* data) { prepareForRendering(); - return m_origVtable.pfnDrawPrimitive2(m_device, &data); + return m_origVtable.pfnDrawPrimitive2(m_device, data); } - HRESULT Device::drawRectPatch(const D3DDDIARG_DRAWRECTPATCH& data, const D3DDDIRECTPATCH_INFO* info, + HRESULT Device::drawRectPatch(const D3DDDIARG_DRAWRECTPATCH* data, const D3DDDIRECTPATCH_INFO* info, const FLOAT* patch) { prepareForRendering(); - return m_origVtable.pfnDrawRectPatch(m_device, &data, info, patch); + return m_origVtable.pfnDrawRectPatch(m_device, data, info, patch); } - HRESULT Device::drawTriPatch(const D3DDDIARG_DRAWTRIPATCH& data, const D3DDDITRIPATCH_INFO* info, + HRESULT Device::drawTriPatch(const D3DDDIARG_DRAWTRIPATCH* data, const D3DDDITRIPATCH_INFO* info, const FLOAT* patch) { prepareForRendering(); - return m_origVtable.pfnDrawTriPatch(m_device, &data, info, patch); + return m_origVtable.pfnDrawTriPatch(m_device, data, info, patch); } - HRESULT Device::lock(D3DDDIARG_LOCK& data) + HRESULT Device::flush() { - auto it = m_resources.find(data.hResource); + if (!s_isFlushEnabled) + { + return S_OK; + } + return m_origVtable.pfnFlush(m_device); + } + + HRESULT Device::flush1(UINT FlushFlags) + { + if (!s_isFlushEnabled && 0 == FlushFlags) + { + return S_OK; + } + return m_origVtable.pfnFlush1(m_device, FlushFlags); + } + + HRESULT Device::lock(D3DDDIARG_LOCK* data) + { + auto it = m_resources.find(data->hResource); if (it != m_resources.end()) { - return it->second.lock(data); + return it->second.lock(*data); } - return m_origVtable.pfnLock(m_device, &data); + return m_origVtable.pfnLock(m_device, data); } - HRESULT Device::openResource(D3DDDIARG_OPENRESOURCE& data) + HRESULT Device::openResource(D3DDDIARG_OPENRESOURCE* data) { - HRESULT result = m_origVtable.pfnOpenResource(m_device, &data); - if (SUCCEEDED(result) && data.Flags.Fullscreen) + HRESULT result = m_origVtable.pfnOpenResource(m_device, data); + if (SUCCEEDED(result) && data->Flags.Fullscreen) { - m_sharedPrimary = data.hResource; + m_sharedPrimary = data->hResource; } return result; } - HRESULT Device::present(const D3DDDIARG_PRESENT& data) + HRESULT Device::present(const D3DDDIARG_PRESENT* data) { - prepareForRendering(data.hSrcResource, data.SrcSubResourceIndex, true); - return m_origVtable.pfnPresent(m_device, &data); + prepareForRendering(data->hSrcResource, data->SrcSubResourceIndex, true); + return m_origVtable.pfnPresent(m_device, data); } - HRESULT Device::present1(D3DDDIARG_PRESENT1& data) + HRESULT Device::present1(D3DDDIARG_PRESENT1* data) { - for (UINT i = 0; i < data.SrcResources; ++i) + for (UINT i = 0; i < data->SrcResources; ++i) { - prepareForRendering(data.phSrcResources[i].hResource, data.phSrcResources[i].SubResourceIndex, true); + prepareForRendering(data->phSrcResources[i].hResource, data->phSrcResources[i].SubResourceIndex, true); } - return m_origVtable.pfnPresent1(m_device, &data); + return m_origVtable.pfnPresent1(m_device, data); } - HRESULT Device::setRenderTarget(const D3DDDIARG_SETRENDERTARGET& data) + HRESULT Device::setRenderTarget(const D3DDDIARG_SETRENDERTARGET* data) { - HRESULT result = m_origVtable.pfnSetRenderTarget(m_device, &data); - if (SUCCEEDED(result) && 0 == data.RenderTargetIndex) + HRESULT result = m_origVtable.pfnSetRenderTarget(m_device, data); + if (SUCCEEDED(result) && 0 == data->RenderTargetIndex) { - m_renderTarget = getResource(data.hRenderTarget); - m_renderTargetSubResourceIndex = data.SubResourceIndex; + m_renderTarget = getResource(data->hRenderTarget); + m_renderTargetSubResourceIndex = data->SubResourceIndex; } return result; } - HRESULT Device::setStreamSource(const D3DDDIARG_SETSTREAMSOURCE& data) + HRESULT Device::setStreamSource(const D3DDDIARG_SETSTREAMSOURCE* data) { - HRESULT result = m_origVtable.pfnSetStreamSource(m_device, &data); - if (SUCCEEDED(result) && 0 == data.Stream) + HRESULT result = m_origVtable.pfnSetStreamSource(m_device, data); + if (SUCCEEDED(result) && 0 == data->Stream) { - m_streamSourceData = data; - m_streamSource = getResource(data.hVertexBuffer); + m_streamSourceData = *data; + m_streamSource = getResource(data->hVertexBuffer); } return result; } - HRESULT Device::setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM& data, const void* umBuffer) + HRESULT Device::setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM* data, const void* umBuffer) { - HRESULT result = m_origVtable.pfnSetStreamSourceUm(m_device, &data, umBuffer); - if (SUCCEEDED(result) && 0 == data.Stream) + HRESULT result = m_origVtable.pfnSetStreamSourceUm(m_device, data, umBuffer); + if (SUCCEEDED(result) && 0 == data->Stream) { m_streamSourceData = {}; m_streamSource = nullptr; @@ -236,26 +254,26 @@ namespace D3dDdi return result; } - HRESULT Device::unlock(const D3DDDIARG_UNLOCK& data) + HRESULT Device::unlock(const D3DDDIARG_UNLOCK* data) { - auto it = m_resources.find(data.hResource); + auto it = m_resources.find(data->hResource); if (it != m_resources.end()) { - return it->second.unlock(data); + return it->second.unlock(*data); } - return m_origVtable.pfnUnlock(m_device, &data); + return m_origVtable.pfnUnlock(m_device, data); } - HRESULT Device::updateWInfo(const D3DDDIARG_WINFO& data) + HRESULT Device::updateWInfo(const D3DDDIARG_WINFO* data) { - if (1.0f == data.WNear && 1.0f == data.WFar) + if (1.0f == data->WNear && 1.0f == data->WFar) { D3DDDIARG_WINFO wInfo = {}; wInfo.WNear = 0.0f; wInfo.WFar = 1.0f; return m_origVtable.pfnUpdateWInfo(m_device, &wInfo); } - return m_origVtable.pfnUpdateWInfo(m_device, &data); + return m_origVtable.pfnUpdateWInfo(m_device, data); } Resource* Device::getGdiResource() @@ -307,6 +325,11 @@ namespace D3dDdi return it != m_resources.end() ? &it->second : nullptr; } + void Device::enableFlush(bool enable) + { + s_isFlushEnabled = enable; + } + Resource* Device::findResource(HANDLE resource) { for (auto& device : s_devices) @@ -322,6 +345,7 @@ namespace D3dDdi void Device::setGdiResourceHandle(HANDLE resource) { + ScopedCriticalSection lock; if ((!resource && !g_gdiResource) || (g_gdiResource && resource == *g_gdiResource)) { @@ -348,4 +372,5 @@ namespace D3dDdi } std::map Device::s_devices; + bool Device::s_isFlushEnabled = true; } diff --git a/DDrawCompat/D3dDdi/Device.h b/DDrawCompat/D3dDdi/Device.h index 7a47d3d..2c782af 100644 --- a/DDrawCompat/D3dDdi/Device.h +++ b/DDrawCompat/D3dDdi/Device.h @@ -17,30 +17,32 @@ namespace D3dDdi public: operator HANDLE() const { return m_device; } - HRESULT blt(const D3DDDIARG_BLT& data); - HRESULT clear(const D3DDDIARG_CLEAR& data, UINT numRect, const RECT* rect); - HRESULT colorFill(const D3DDDIARG_COLORFILL& data); - HRESULT createResource(D3DDDIARG_CREATERESOURCE& data); - HRESULT createResource2(D3DDDIARG_CREATERESOURCE2& data); + HRESULT blt(const D3DDDIARG_BLT* data); + HRESULT clear(const D3DDDIARG_CLEAR* data, UINT numRect, const RECT* rect); + HRESULT colorFill(const D3DDDIARG_COLORFILL* data); + HRESULT createResource(D3DDDIARG_CREATERESOURCE* data); + HRESULT createResource2(D3DDDIARG_CREATERESOURCE2* data); HRESULT destroyResource(HANDLE resource); - HRESULT drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE& data); - HRESULT drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2& data, + HRESULT drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE* data); + HRESULT drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2* data, UINT indicesSize, const void* indexBuffer, const UINT* flagBuffer); - HRESULT drawPrimitive(const D3DDDIARG_DRAWPRIMITIVE& data, const UINT* flagBuffer); - HRESULT drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2& data); - HRESULT drawRectPatch(const D3DDDIARG_DRAWRECTPATCH& data, const D3DDDIRECTPATCH_INFO* info, + HRESULT drawPrimitive(const D3DDDIARG_DRAWPRIMITIVE* data, const UINT* flagBuffer); + HRESULT drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2* data); + HRESULT drawRectPatch(const D3DDDIARG_DRAWRECTPATCH* data, const D3DDDIRECTPATCH_INFO* info, const FLOAT* patch); - HRESULT drawTriPatch(const D3DDDIARG_DRAWTRIPATCH& data, const D3DDDITRIPATCH_INFO* info, + HRESULT drawTriPatch(const D3DDDIARG_DRAWTRIPATCH* data, const D3DDDITRIPATCH_INFO* info, const FLOAT* patch); - HRESULT lock(D3DDDIARG_LOCK& data); - HRESULT openResource(D3DDDIARG_OPENRESOURCE& data); - HRESULT present(const D3DDDIARG_PRESENT& data); - HRESULT present1(D3DDDIARG_PRESENT1& data); - HRESULT setRenderTarget(const D3DDDIARG_SETRENDERTARGET& data); - HRESULT setStreamSource(const D3DDDIARG_SETSTREAMSOURCE& data); - HRESULT setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM& data, const void* umBuffer); - HRESULT unlock(const D3DDDIARG_UNLOCK& data); - HRESULT updateWInfo(const D3DDDIARG_WINFO& data); + HRESULT flush(); + HRESULT flush1(UINT FlushFlags); + HRESULT lock(D3DDDIARG_LOCK* data); + HRESULT openResource(D3DDDIARG_OPENRESOURCE* data); + HRESULT present(const D3DDDIARG_PRESENT* data); + HRESULT present1(D3DDDIARG_PRESENT1* data); + HRESULT setRenderTarget(const D3DDDIARG_SETRENDERTARGET* data); + HRESULT setStreamSource(const D3DDDIARG_SETSTREAMSOURCE* data); + HRESULT setStreamSourceUm(const D3DDDIARG_SETSTREAMSOURCEUM* data, const void* umBuffer); + HRESULT unlock(const D3DDDIARG_UNLOCK* data); + HRESULT updateWInfo(const D3DDDIARG_WINFO* data); Adapter& getAdapter() const { return m_adapter; } const D3DDDI_DEVICEFUNCS& getOrigVtable() const { return m_origVtable; } @@ -53,6 +55,7 @@ namespace D3dDdi static Device& get(HANDLE device); static void remove(HANDLE device); + static void enableFlush(bool enable); static Resource* findResource(HANDLE resource); static Resource* getGdiResource(); static void setGdiResourceHandle(HANDLE resource); @@ -75,5 +78,6 @@ namespace D3dDdi Resource* m_streamSource; static std::map s_devices; + static bool s_isFlushEnabled; }; } diff --git a/DDrawCompat/D3dDdi/DeviceFuncs.cpp b/DDrawCompat/D3dDdi/DeviceFuncs.cpp index 785c425..60f9867 100644 --- a/DDrawCompat/D3dDdi/DeviceFuncs.cpp +++ b/DDrawCompat/D3dDdi/DeviceFuncs.cpp @@ -3,10 +3,10 @@ namespace { - template - HRESULT WINAPI deviceFunc(HANDLE device, Arg* data, Params... params) + template + HRESULT WINAPI deviceFunc(HANDLE device, Params... params) { - return (D3dDdi::Device::get(device).*deviceMethod)(*data, params...); + return (D3dDdi::Device::get(device).*deviceMethod)(params...); } HRESULT APIENTRY destroyDevice(HANDLE hDevice) @@ -18,11 +18,6 @@ namespace } return result; } - - HRESULT APIENTRY destroyResource(HANDLE hDevice, HANDLE hResource) - { - return D3dDdi::Device::get(hDevice).destroyResource(hResource); - } } #define DEVICE_FUNC(func) deviceFunc @@ -42,13 +37,15 @@ namespace D3dDdi vtable.pfnCreateResource = &DEVICE_FUNC(createResource); vtable.pfnCreateResource2 = &DEVICE_FUNC(createResource2); vtable.pfnDestroyDevice = &destroyDevice; - vtable.pfnDestroyResource = &destroyResource; + vtable.pfnDestroyResource = &DEVICE_FUNC(destroyResource); vtable.pfnDrawIndexedPrimitive = &DEVICE_FUNC(drawIndexedPrimitive); vtable.pfnDrawIndexedPrimitive2 = &DEVICE_FUNC(drawIndexedPrimitive2); vtable.pfnDrawPrimitive = &DEVICE_FUNC(drawPrimitive); vtable.pfnDrawPrimitive2 = &DEVICE_FUNC(drawPrimitive2); vtable.pfnDrawRectPatch = &DEVICE_FUNC(drawRectPatch); vtable.pfnDrawTriPatch = &DEVICE_FUNC(drawTriPatch); + vtable.pfnFlush = &DEVICE_FUNC(flush); + vtable.pfnFlush1 = &DEVICE_FUNC(flush1); vtable.pfnLock = &DEVICE_FUNC(lock); vtable.pfnOpenResource = &DEVICE_FUNC(openResource); vtable.pfnPresent = &DEVICE_FUNC(present); diff --git a/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h b/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h index af7481b..51bf5a2 100644 --- a/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h +++ b/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h @@ -5,6 +5,8 @@ #include #include +#include + std::ostream& operator<<(std::ostream& os, const D3DDDI_ALLOCATIONLIST& data); std::ostream& operator<<(std::ostream& os, const D3DDDI_PATCHLOCATIONLIST& data); std::ostream& operator<<(std::ostream& os, const D3DDDIARG_CREATEDEVICE& data); diff --git a/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h b/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h index 0fe8264..27896d1 100644 --- a/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h +++ b/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h @@ -7,6 +7,8 @@ #include #include <../km/d3dkmthk.h> +#include + std::ostream& operator<<(std::ostream& os, const D3DDDI_ALLOCATIONINFO& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_ALLOCATE& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_DEALLOCATE& data); diff --git a/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.cpp b/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.cpp index 280835e..18b18c9 100644 --- a/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.cpp +++ b/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.cpp @@ -1,11 +1,18 @@ -#include "Common/Log.h" -#include "D3dDdi/Log/DeviceFuncsLog.h" +#include +#include -std::ostream& operator<<(std::ostream& os, const D3DDDI_RATIONAL& val) +std::ostream& operator<<(std::ostream& os, D3DDDI_POOL val) { - return Compat::LogStruct(os) - << val.Numerator - << val.Denominator; + switch (val) + { + LOG_CONST_CASE(D3DDDIPOOL_SYSTEMMEM); + LOG_CONST_CASE(D3DDDIPOOL_VIDEOMEMORY); + LOG_CONST_CASE(D3DDDIPOOL_LOCALVIDMEM); + LOG_CONST_CASE(D3DDDIPOOL_NONLOCALVIDMEM); + LOG_CONST_CASE(D3DDDIPOOL_STAGINGMEM); + } + + return os << "D3DDDIPOOL_" << static_cast(val); } std::ostream& operator<<(std::ostream& os, const D3DDDI_SURFACEINFO& val) @@ -254,3 +261,202 @@ std::ostream& operator<<(std::ostream& os, const D3DDDIBOX& box) << box.Front << box.Back; } + +std::ostream& operator<<(std::ostream& os, D3DDDIRENDERSTATETYPE val) +{ + switch (val) + { + LOG_CONST_CASE(D3DDDIRS_ZENABLE); + LOG_CONST_CASE(D3DDDIRS_FILLMODE); + LOG_CONST_CASE(D3DDDIRS_SHADEMODE); + LOG_CONST_CASE(D3DDDIRS_LINEPATTERN); + LOG_CONST_CASE(D3DDDIRS_ZWRITEENABLE); + LOG_CONST_CASE(D3DDDIRS_ALPHATESTENABLE); + LOG_CONST_CASE(D3DDDIRS_LASTPIXEL); + LOG_CONST_CASE(D3DDDIRS_SRCBLEND); + LOG_CONST_CASE(D3DDDIRS_DESTBLEND); + LOG_CONST_CASE(D3DDDIRS_CULLMODE); + LOG_CONST_CASE(D3DDDIRS_ZFUNC); + LOG_CONST_CASE(D3DDDIRS_ALPHAREF); + LOG_CONST_CASE(D3DDDIRS_ALPHAFUNC); + LOG_CONST_CASE(D3DDDIRS_DITHERENABLE); + LOG_CONST_CASE(D3DDDIRS_ALPHABLENDENABLE); + LOG_CONST_CASE(D3DDDIRS_FOGENABLE); + LOG_CONST_CASE(D3DDDIRS_SPECULARENABLE); + LOG_CONST_CASE(D3DDDIRS_ZVISIBLE); + LOG_CONST_CASE(D3DDDIRS_FOGCOLOR); + LOG_CONST_CASE(D3DDDIRS_FOGTABLEMODE); + LOG_CONST_CASE(D3DDDIRS_FOGSTART); + LOG_CONST_CASE(D3DDDIRS_FOGEND); + LOG_CONST_CASE(D3DDDIRS_FOGDENSITY); + LOG_CONST_CASE(D3DDDIRS_EDGEANTIALIAS); + LOG_CONST_CASE(D3DDDIRS_COLORKEYENABLE); + LOG_CONST_CASE(D3DDDIRS_OLDALPHABLENDENABLE); + LOG_CONST_CASE(D3DDDIRS_ZBIAS); + LOG_CONST_CASE(D3DDDIRS_RANGEFOGENABLE); + LOG_CONST_CASE(D3DDDIRS_TRANSLUCENTSORTINDEPENDENT); + LOG_CONST_CASE(D3DDDIRS_STENCILENABLE); + LOG_CONST_CASE(D3DDDIRS_STENCILFAIL); + LOG_CONST_CASE(D3DDDIRS_STENCILZFAIL); + LOG_CONST_CASE(D3DDDIRS_STENCILPASS); + LOG_CONST_CASE(D3DDDIRS_STENCILFUNC); + LOG_CONST_CASE(D3DDDIRS_STENCILREF); + LOG_CONST_CASE(D3DDDIRS_STENCILMASK); + LOG_CONST_CASE(D3DDDIRS_STENCILWRITEMASK); + LOG_CONST_CASE(D3DDDIRS_TEXTUREFACTOR); + LOG_CONST_CASE(D3DDDIRS_SCENECAPTURE); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN00); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN01); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN02); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN03); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN04); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN05); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN06); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN07); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN08); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN09); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN10); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN11); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN12); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN13); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN14); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN15); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN16); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN17); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN18); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN19); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN20); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN21); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN22); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN23); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN24); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN25); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN26); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN27); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN28); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN29); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN30); + LOG_CONST_CASE(D3DDDIRS_STIPPLEPATTERN31); + LOG_CONST_CASE(D3DDDIRS_WRAP0); + LOG_CONST_CASE(D3DDDIRS_WRAP1); + LOG_CONST_CASE(D3DDDIRS_WRAP2); + LOG_CONST_CASE(D3DDDIRS_WRAP3); + LOG_CONST_CASE(D3DDDIRS_WRAP4); + LOG_CONST_CASE(D3DDDIRS_WRAP5); + LOG_CONST_CASE(D3DDDIRS_WRAP6); + LOG_CONST_CASE(D3DDDIRS_WRAP7); + LOG_CONST_CASE(D3DDDIRS_CLIPPING); + LOG_CONST_CASE(D3DDDIRS_LIGHTING); + LOG_CONST_CASE(D3DDDIRS_AMBIENT); + LOG_CONST_CASE(D3DDDIRS_FOGVERTEXMODE); + LOG_CONST_CASE(D3DDDIRS_COLORVERTEX); + LOG_CONST_CASE(D3DDDIRS_LOCALVIEWER); + LOG_CONST_CASE(D3DDDIRS_NORMALIZENORMALS); + LOG_CONST_CASE(D3DDDIRS_COLORKEYBLENDENABLE); + LOG_CONST_CASE(D3DDDIRS_DIFFUSEMATERIALSOURCE); + LOG_CONST_CASE(D3DDDIRS_SPECULARMATERIALSOURCE); + LOG_CONST_CASE(D3DDDIRS_AMBIENTMATERIALSOURCE); + LOG_CONST_CASE(D3DDDIRS_EMISSIVEMATERIALSOURCE); + LOG_CONST_CASE(D3DDDIRS_VERTEXBLEND); + LOG_CONST_CASE(D3DDDIRS_CLIPPLANEENABLE); + LOG_CONST_CASE(D3DDDIRS_SOFTWAREVERTEXPROCESSING); + LOG_CONST_CASE(D3DDDIRS_POINTSIZE); + LOG_CONST_CASE(D3DDDIRS_POINTSIZE_MIN); + LOG_CONST_CASE(D3DDDIRS_POINTSPRITEENABLE); + LOG_CONST_CASE(D3DDDIRS_POINTSCALEENABLE); + LOG_CONST_CASE(D3DDDIRS_POINTSCALE_A); + LOG_CONST_CASE(D3DDDIRS_POINTSCALE_B); + LOG_CONST_CASE(D3DDDIRS_POINTSCALE_C); + LOG_CONST_CASE(D3DDDIRS_MULTISAMPLEANTIALIAS); + LOG_CONST_CASE(D3DDDIRS_MULTISAMPLEMASK); + LOG_CONST_CASE(D3DDDIRS_PATCHEDGESTYLE); + LOG_CONST_CASE(D3DDDIRS_PATCHSEGMENTS); + LOG_CONST_CASE(D3DDDIRS_DEBUGMONITORTOKEN); + LOG_CONST_CASE(D3DDDIRS_POINTSIZE_MAX); + LOG_CONST_CASE(D3DDDIRS_INDEXEDVERTEXBLENDENABLE); + LOG_CONST_CASE(D3DDDIRS_COLORWRITEENABLE); + LOG_CONST_CASE(D3DDDIRS_DELETERTPATCH); + LOG_CONST_CASE(D3DDDIRS_TWEENFACTOR); + LOG_CONST_CASE(D3DDDIRS_BLENDOP); + LOG_CONST_CASE(D3DDDIRS_POSITIONDEGREE); + LOG_CONST_CASE(D3DDDIRS_NORMALDEGREE); + LOG_CONST_CASE(D3DDDIRS_SCISSORTESTENABLE); + LOG_CONST_CASE(D3DDDIRS_SLOPESCALEDEPTHBIAS); + LOG_CONST_CASE(D3DDDIRS_ANTIALIASEDLINEENABLE); + LOG_CONST_CASE(D3DDDIRS_MINTESSELLATIONLEVEL); + LOG_CONST_CASE(D3DDDIRS_MAXTESSELLATIONLEVEL); + LOG_CONST_CASE(D3DDDIRS_ADAPTIVETESS_X); + LOG_CONST_CASE(D3DDDIRS_ADAPTIVETESS_Y); + LOG_CONST_CASE(D3DDDIRS_ADAPTIVETESS_Z); + LOG_CONST_CASE(D3DDDIRS_ADAPTIVETESS_W); + LOG_CONST_CASE(D3DDDIRS_ENABLEADAPTIVETESSELLATION); + LOG_CONST_CASE(D3DDDIRS_TWOSIDEDSTENCILMODE); + LOG_CONST_CASE(D3DDDIRS_CCW_STENCILFAIL); + LOG_CONST_CASE(D3DDDIRS_CCW_STENCILZFAIL); + LOG_CONST_CASE(D3DDDIRS_CCW_STENCILPASS); + LOG_CONST_CASE(D3DDDIRS_CCW_STENCILFUNC); + LOG_CONST_CASE(D3DDDIRS_COLORWRITEENABLE1); + LOG_CONST_CASE(D3DDDIRS_COLORWRITEENABLE2); + LOG_CONST_CASE(D3DDDIRS_COLORWRITEENABLE3); + LOG_CONST_CASE(D3DDDIRS_BLENDFACTOR); + LOG_CONST_CASE(D3DDDIRS_SRGBWRITEENABLE); + LOG_CONST_CASE(D3DDDIRS_DEPTHBIAS); + LOG_CONST_CASE(D3DDDIRS_WRAP8); + LOG_CONST_CASE(D3DDDIRS_WRAP9); + LOG_CONST_CASE(D3DDDIRS_WRAP10); + LOG_CONST_CASE(D3DDDIRS_WRAP11); + LOG_CONST_CASE(D3DDDIRS_WRAP12); + LOG_CONST_CASE(D3DDDIRS_WRAP13); + LOG_CONST_CASE(D3DDDIRS_WRAP14); + LOG_CONST_CASE(D3DDDIRS_WRAP15); + LOG_CONST_CASE(D3DDDIRS_SEPARATEALPHABLENDENABLE); + LOG_CONST_CASE(D3DDDIRS_SRCBLENDALPHA); + LOG_CONST_CASE(D3DDDIRS_DESTBLENDALPHA); + LOG_CONST_CASE(D3DDDIRS_BLENDOPALPHA); + } + + return os << "D3DDDIRS_" << static_cast(val); +} + +std::ostream& operator<<(std::ostream& os, D3DDDITEXTURESTAGESTATETYPE val) +{ + switch (val) + { + LOG_CONST_CASE(D3DDDITSS_TEXTUREMAP); + LOG_CONST_CASE(D3DDDITSS_COLOROP); + LOG_CONST_CASE(D3DDDITSS_COLORARG1); + LOG_CONST_CASE(D3DDDITSS_COLORARG2); + LOG_CONST_CASE(D3DDDITSS_ALPHAOP); + LOG_CONST_CASE(D3DDDITSS_ALPHAARG1); + LOG_CONST_CASE(D3DDDITSS_ALPHAARG2); + LOG_CONST_CASE(D3DDDITSS_BUMPENVMAT00); + LOG_CONST_CASE(D3DDDITSS_BUMPENVMAT01); + LOG_CONST_CASE(D3DDDITSS_BUMPENVMAT10); + LOG_CONST_CASE(D3DDDITSS_BUMPENVMAT11); + LOG_CONST_CASE(D3DDDITSS_TEXCOORDINDEX); + LOG_CONST_CASE(D3DDDITSS_ADDRESSU); + LOG_CONST_CASE(D3DDDITSS_ADDRESSV); + LOG_CONST_CASE(D3DDDITSS_BORDERCOLOR); + LOG_CONST_CASE(D3DDDITSS_MAGFILTER); + LOG_CONST_CASE(D3DDDITSS_MINFILTER); + LOG_CONST_CASE(D3DDDITSS_MIPFILTER); + LOG_CONST_CASE(D3DDDITSS_MIPMAPLODBIAS); + LOG_CONST_CASE(D3DDDITSS_MAXMIPLEVEL); + LOG_CONST_CASE(D3DDDITSS_MAXANISOTROPY); + LOG_CONST_CASE(D3DDDITSS_BUMPENVLSCALE); + LOG_CONST_CASE(D3DDDITSS_BUMPENVLOFFSET); + LOG_CONST_CASE(D3DDDITSS_TEXTURETRANSFORMFLAGS); + LOG_CONST_CASE(D3DDDITSS_ADDRESSW); + LOG_CONST_CASE(D3DDDITSS_COLORARG0); + LOG_CONST_CASE(D3DDDITSS_ALPHAARG0); + LOG_CONST_CASE(D3DDDITSS_RESULTARG); + LOG_CONST_CASE(D3DDDITSS_SRGBTEXTURE); + LOG_CONST_CASE(D3DDDITSS_ELEMENTINDEX); + LOG_CONST_CASE(D3DDDITSS_DMAPOFFSET); + LOG_CONST_CASE(D3DDDITSS_CONSTANT); + LOG_CONST_CASE(D3DDDITSS_DISABLETEXTURECOLORKEY); + LOG_CONST_CASE(D3DDDITSS_TEXTURECOLORKEYVAL); + } + + return os << "D3DDDITSS_" << static_cast(val); +} diff --git a/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.h b/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.h index f27a37b..a188706 100644 --- a/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.h +++ b/DDrawCompat/D3dDdi/Log/DeviceFuncsLog.h @@ -5,7 +5,9 @@ #include #include -std::ostream& operator<<(std::ostream& os, const D3DDDI_RATIONAL& val); +#include + +std::ostream& operator<<(std::ostream& os, D3DDDI_POOL val); std::ostream& operator<<(std::ostream& os, const D3DDDI_SURFACEINFO& val); std::ostream& operator<<(std::ostream& os, const D3DDDIARG_BLT& val); std::ostream& operator<<(std::ostream& os, const D3DDDIARG_CLEAR& val); @@ -30,3 +32,5 @@ std::ostream& operator<<(std::ostream& os, const D3DDDIARG_UNLOCK& val); std::ostream& operator<<(std::ostream& os, const D3DDDIARG_WINFO& val); std::ostream& operator<<(std::ostream& os, const D3DDDIARG_ZRANGE& val); std::ostream& operator<<(std::ostream& os, const D3DDDIBOX& val); +std::ostream& operator<<(std::ostream& os, D3DDDIRENDERSTATETYPE val); +std::ostream& operator<<(std::ostream& os, D3DDDITEXTURESTAGESTATETYPE val); diff --git a/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h b/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h index 9cab1e6..76577fc 100644 --- a/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h +++ b/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h @@ -7,6 +7,8 @@ #include #include <../km/d3dkmthk.h> +#include + std::ostream& operator<<(std::ostream& os, const LUID& luid); std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATECONTEXT& data); std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATECONTEXTVIRTUAL& data); diff --git a/DDrawCompat/DDrawCompat.vcxproj b/DDrawCompat/DDrawCompat.vcxproj index f1b4923..138e408 100644 --- a/DDrawCompat/DDrawCompat.vcxproj +++ b/DDrawCompat/DDrawCompat.vcxproj @@ -158,6 +158,7 @@ + @@ -246,6 +247,7 @@ + diff --git a/DDrawCompat/DDrawCompat.vcxproj.filters b/DDrawCompat/DDrawCompat.vcxproj.filters index 3116275..f345cf0 100644 --- a/DDrawCompat/DDrawCompat.vcxproj.filters +++ b/DDrawCompat/DDrawCompat.vcxproj.filters @@ -384,6 +384,9 @@ Header Files\Dll + + Header Files\D3dDdi\Log + @@ -587,5 +590,8 @@ Source Files\Dll + + Source Files\D3dDdi\Log + \ No newline at end of file diff --git a/DDrawCompat/Direct3d/Direct3dDevice.cpp b/DDrawCompat/Direct3d/Direct3dDevice.cpp index 6d80714..0848545 100644 --- a/DDrawCompat/Direct3d/Direct3dDevice.cpp +++ b/DDrawCompat/Direct3d/Direct3dDevice.cpp @@ -1,11 +1,23 @@ -#include "Common/CompatPtr.h" -#include "Common/CompatRef.h" -#include "Direct3d/DepthBuffer.h" -#include "Direct3d/Direct3dDevice.h" -#include "Direct3d/Types.h" +#include +#include +#include +#include +#include +#include namespace { + HRESULT STDMETHODCALLTYPE execute(IDirect3DDevice* This, + LPDIRECT3DEXECUTEBUFFER lpDirect3DExecuteBuffer, LPDIRECT3DVIEWPORT lpDirect3DViewport, DWORD dwFlags) + { + D3dDdi::ScopedCriticalSection lock; + D3dDdi::Device::enableFlush(false); + HRESULT result = CompatVtable::s_origVtable.Execute( + This, lpDirect3DExecuteBuffer, lpDirect3DViewport, dwFlags); + D3dDdi::Device::enableFlush(true); + return result; + } + template void fixSupportedZBufferBitDepths(CompatRef d3dDevice, TD3dDeviceDesc& desc) { @@ -33,6 +45,16 @@ namespace } return result; } + + void setCompatVtable(IDirect3DDeviceVtbl& vtable) + { + vtable.Execute = &execute; + } + + template + void setCompatVtable(TDirect3dDeviceVtbl& /*vtable*/) + { + } } namespace Direct3d @@ -40,6 +62,7 @@ namespace Direct3d template void Direct3dDevice::setCompatVtable(Vtable& vtable) { + ::setCompatVtable(vtable); vtable.GetCaps = &getCaps; } diff --git a/DDrawCompat/Gdi/Dc.cpp b/DDrawCompat/Gdi/Dc.cpp index 8df8a92..c5aee12 100644 --- a/DDrawCompat/Gdi/Dc.cpp +++ b/DDrawCompat/Gdi/Dc.cpp @@ -185,6 +185,8 @@ namespace Gdi return nullptr; } + RECT virtualScreenBounds = Gdi::VirtualScreen::getBounds(); + D3dDdi::ScopedCriticalSection driverLock; Compat::ScopedCriticalSection lock(g_cs); auto it = g_origDcToCompatDc.find(origDc); @@ -210,7 +212,6 @@ namespace Gdi POINT origin = {}; GetDCOrgEx(origDc, &origin); - RECT virtualScreenBounds = Gdi::VirtualScreen::getBounds(); if (wnd && GetDesktopWindow() != wnd) { origin.x -= virtualScreenBounds.left;