mirror of
https://github.com/narzoul/DDrawCompat
synced 2024-12-30 08:55:36 +01:00
Suppress flushes from execute buffers
Mitigates performance issues in Rowan's Mig Alley (issue #12).
This commit is contained in:
narzoul
parent
8f67fd158c
commit
ca9404ec6f
@ -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);
|
||||
|
||||
@ -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 <typename Arg>
|
||||
@ -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<HANDLE, Device> Device::s_devices;
|
||||
bool Device::s_isFlushEnabled = true;
|
||||
}
|
||||
|
||||
@ -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<HANDLE, Device> s_devices;
|
||||
static bool s_isFlushEnabled;
|
||||
};
|
||||
}
|
||||
|
||||
@ -3,10 +3,10 @@
|
||||
|
||||
namespace
|
||||
{
|
||||
template <typename DeviceMethodPtr, DeviceMethodPtr deviceMethod, typename Arg, typename... Params>
|
||||
HRESULT WINAPI deviceFunc(HANDLE device, Arg* data, Params... params)
|
||||
template <typename DeviceMethodPtr, DeviceMethodPtr deviceMethod, typename... Params>
|
||||
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<decltype(&Device::func), &Device::func>
|
||||
@ -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);
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#include <d3d.h>
|
||||
#include <d3dumddi.h>
|
||||
|
||||
#include <D3dDdi/Log/CommonLog.h>
|
||||
|
||||
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);
|
||||
|
||||
@ -7,6 +7,8 @@
|
||||
#include <winternl.h>
|
||||
#include <../km/d3dkmthk.h>
|
||||
|
||||
#include <D3dDdi/Log/CommonLog.h>
|
||||
|
||||
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);
|
||||
|
||||
@ -1,11 +1,18 @@
|
||||
#include "Common/Log.h"
|
||||
#include "D3dDdi/Log/DeviceFuncsLog.h"
|
||||
#include <Common/Log.h>
|
||||
#include <D3dDdi/Log/DeviceFuncsLog.h>
|
||||
|
||||
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<DWORD>(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<DWORD>(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<DWORD>(val);
|
||||
}
|
||||
|
||||
@ -5,7 +5,9 @@
|
||||
#include <d3d.h>
|
||||
#include <d3dumddi.h>
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const D3DDDI_RATIONAL& val);
|
||||
#include <D3dDdi/Log/CommonLog.h>
|
||||
|
||||
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);
|
||||
|
||||
@ -7,6 +7,8 @@
|
||||
#include <winternl.h>
|
||||
#include <../km/d3dkmthk.h>
|
||||
|
||||
#include <D3dDdi/Log/CommonLog.h>
|
||||
|
||||
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);
|
||||
|
||||
@ -158,6 +158,7 @@
|
||||
<ClInclude Include="D3dDdi\Hooks.h" />
|
||||
<ClInclude Include="D3dDdi\KernelModeThunks.h" />
|
||||
<ClInclude Include="D3dDdi\Log\AdapterFuncsLog.h" />
|
||||
<ClInclude Include="D3dDdi\Log\CommonLog.h" />
|
||||
<ClInclude Include="D3dDdi\Log\DeviceCallbacksLog.h" />
|
||||
<ClInclude Include="D3dDdi\Log\DeviceFuncsLog.h" />
|
||||
<ClInclude Include="D3dDdi\Log\KernelModeThunksLog.h" />
|
||||
@ -246,6 +247,7 @@
|
||||
<ClCompile Include="D3dDdi\Hooks.cpp" />
|
||||
<ClCompile Include="D3dDdi\KernelModeThunks.cpp" />
|
||||
<ClCompile Include="D3dDdi\Log\AdapterFuncsLog.cpp" />
|
||||
<ClCompile Include="D3dDdi\Log\CommonLog.cpp" />
|
||||
<ClCompile Include="D3dDdi\Log\DeviceCallbacksLog.cpp" />
|
||||
<ClCompile Include="D3dDdi\Log\DeviceFuncsLog.cpp" />
|
||||
<ClCompile Include="D3dDdi\Log\KernelModeThunksLog.cpp" />
|
||||
|
||||
@ -384,6 +384,9 @@
|
||||
<ClInclude Include="Dll\Dll.h">
|
||||
<Filter>Header Files\Dll</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="D3dDdi\Log\CommonLog.h">
|
||||
<Filter>Header Files\D3dDdi\Log</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="Gdi\Gdi.cpp">
|
||||
@ -587,5 +590,8 @@
|
||||
<ClCompile Include="Dll\Dll.cpp">
|
||||
<Filter>Source Files\Dll</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="D3dDdi\Log\CommonLog.cpp">
|
||||
<Filter>Source Files\D3dDdi\Log</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@ -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 <Common/CompatPtr.h>
|
||||
#include <Common/CompatRef.h>
|
||||
#include <D3dDdi/Device.h>
|
||||
#include <Direct3d/DepthBuffer.h>
|
||||
#include <Direct3d/Direct3dDevice.h>
|
||||
#include <Direct3d/Types.h>
|
||||
|
||||
namespace
|
||||
{
|
||||
HRESULT STDMETHODCALLTYPE execute(IDirect3DDevice* This,
|
||||
LPDIRECT3DEXECUTEBUFFER lpDirect3DExecuteBuffer, LPDIRECT3DVIEWPORT lpDirect3DViewport, DWORD dwFlags)
|
||||
{
|
||||
D3dDdi::ScopedCriticalSection lock;
|
||||
D3dDdi::Device::enableFlush(false);
|
||||
HRESULT result = CompatVtable<IDirect3DDeviceVtbl>::s_origVtable.Execute(
|
||||
This, lpDirect3DExecuteBuffer, lpDirect3DViewport, dwFlags);
|
||||
D3dDdi::Device::enableFlush(true);
|
||||
return result;
|
||||
}
|
||||
|
||||
template <typename TDirect3dDevice, typename TD3dDeviceDesc>
|
||||
void fixSupportedZBufferBitDepths(CompatRef<TDirect3dDevice> d3dDevice, TD3dDeviceDesc& desc)
|
||||
{
|
||||
@ -33,6 +45,16 @@ namespace
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void setCompatVtable(IDirect3DDeviceVtbl& vtable)
|
||||
{
|
||||
vtable.Execute = &execute;
|
||||
}
|
||||
|
||||
template <typename TDirect3dDeviceVtbl>
|
||||
void setCompatVtable(TDirect3dDeviceVtbl& /*vtable*/)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
namespace Direct3d
|
||||
@ -40,6 +62,7 @@ namespace Direct3d
|
||||
template <typename TDirect3dDevice>
|
||||
void Direct3dDevice<TDirect3dDevice>::setCompatVtable(Vtable<TDirect3dDevice>& vtable)
|
||||
{
|
||||
::setCompatVtable(vtable);
|
||||
vtable.GetCaps = &getCaps;
|
||||
}
|
||||
|
||||
|
||||
@ -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;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user