From d898961a7edb83722ec51c75a30a4f0ebda3a48f Mon Sep 17 00:00:00 2001 From: narzoul Date: Tue, 29 Nov 2016 00:00:49 +0100 Subject: [PATCH] Restore legacy double/triple buffered v-sync behavior On recent drivers, double buffered DirectDraw flips no longer wait for the vertical sync before returning and instead just insert the flip into the flip queue for later execution. This effectively results in triple buffered behavior (in the render-ahead sense) and causes up to an extra frame of latency even if the flip queue size is set to 1. To restore the legacy double buffered behavior, each flip waits for the presented frame to leave the flip queue before returning. To restore the legacy triple buffered behavior, the flip queue size is forced to 1. This causes the flip to wait if the previous flip is still pending. --- DDrawCompat/D3dDdi/AdapterFuncs.h | 1 + DDrawCompat/D3dDdi/Hooks.cpp | 27 +- DDrawCompat/D3dDdi/Hooks.h | 3 + DDrawCompat/D3dDdi/KernelModeThunks.cpp | 234 ++++++++++++++++++ DDrawCompat/D3dDdi/KernelModeThunks.h | 11 + DDrawCompat/D3dDdi/Log/AdapterFuncsLog.cpp | 38 +++ DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h | 12 + DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.cpp | 15 ++ DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h | 1 + .../D3dDdi/Log/KernelModeThunksLog.cpp | 116 +++++++++ DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h | 19 ++ DDrawCompat/DDraw/RealPrimarySurface.cpp | 2 +- DDrawCompat/DDrawCompat.vcxproj | 6 + DDrawCompat/DDrawCompat.vcxproj.filters | 18 ++ 14 files changed, 486 insertions(+), 17 deletions(-) create mode 100644 DDrawCompat/D3dDdi/KernelModeThunks.cpp create mode 100644 DDrawCompat/D3dDdi/KernelModeThunks.h create mode 100644 DDrawCompat/D3dDdi/Log/AdapterFuncsLog.cpp create mode 100644 DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h create mode 100644 DDrawCompat/D3dDdi/Log/KernelModeThunksLog.cpp create mode 100644 DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h diff --git a/DDrawCompat/D3dDdi/AdapterFuncs.h b/DDrawCompat/D3dDdi/AdapterFuncs.h index f7006aa..216730a 100644 --- a/DDrawCompat/D3dDdi/AdapterFuncs.h +++ b/DDrawCompat/D3dDdi/AdapterFuncs.h @@ -6,6 +6,7 @@ #include #include "Common/CompatVtable.h" +#include "D3dDdi/Log/AdapterFuncsLog.h" #include "D3dDdi/Visitors/AdapterFuncsVisitor.h" namespace D3dDdi diff --git a/DDrawCompat/D3dDdi/Hooks.cpp b/DDrawCompat/D3dDdi/Hooks.cpp index 47d89b3..bd46202 100644 --- a/DDrawCompat/D3dDdi/Hooks.cpp +++ b/DDrawCompat/D3dDdi/Hooks.cpp @@ -11,6 +11,7 @@ #include "Common/Log.h" #include "D3dDdi/AdapterCallbacks.h" #include "D3dDdi/AdapterFuncs.h" +#include "D3dDdi/KernelModeThunks.h" std::ostream& operator<<(std::ostream& os, const D3DDDIARG_OPENADAPTER& data) { @@ -33,21 +34,6 @@ namespace HRESULT APIENTRY openAdapter(D3DDDIARG_OPENADAPTER* pOpenData); void unhookOpenAdapter(); - NTSTATUS APIENTRY d3dKmtQueryAdapterInfo(const D3DKMT_QUERYADAPTERINFO* pData) - { - NTSTATUS result = CALL_ORIG_FUNC(D3DKMTQueryAdapterInfo)(pData); - if (SUCCEEDED(result) && KMTQAITYPE_UMDRIVERNAME == pData->Type) - { - auto info = static_cast(pData->pPrivateDriverData); - if (g_hookedUmdFileName != info->UmdFileName) - { - unhookOpenAdapter(); - hookOpenAdapter(info->UmdFileName); - } - } - return result; - } - void hookOpenAdapter(const std::wstring& umdFileName) { g_hookedUmdFileName = umdFileName; @@ -99,7 +85,16 @@ namespace D3dDdi void installHooks() { - HOOK_FUNCTION(gdi32, D3DKMTQueryAdapterInfo, d3dKmtQueryAdapterInfo); + KernelModeThunks::installHooks(); + } + + void onUmdFileNameQueried(const std::wstring& umdFileName) + { + if (g_hookedUmdFileName != umdFileName) + { + unhookOpenAdapter(); + hookOpenAdapter(umdFileName); + } } void uninstallHooks() diff --git a/DDrawCompat/D3dDdi/Hooks.h b/DDrawCompat/D3dDdi/Hooks.h index 8c7ab30..12eaeff 100644 --- a/DDrawCompat/D3dDdi/Hooks.h +++ b/DDrawCompat/D3dDdi/Hooks.h @@ -1,8 +1,11 @@ #pragma once +#include + namespace D3dDdi { UINT getDdiVersion(); void installHooks(); + void onUmdFileNameQueried(const std::wstring& umdFileName); void uninstallHooks(); } diff --git a/DDrawCompat/D3dDdi/KernelModeThunks.cpp b/DDrawCompat/D3dDdi/KernelModeThunks.cpp new file mode 100644 index 0000000..416ea44 --- /dev/null +++ b/DDrawCompat/D3dDdi/KernelModeThunks.cpp @@ -0,0 +1,234 @@ +#define CINTERFACE + +#include + +#include +#include +#include <../km/d3dkmthk.h> + +#include "Common/Log.h" +#include "Common/Hook.h" +#include "D3dDdi/Hooks.h" +#include "D3dDdi/KernelModeThunks.h" +#include "DDraw/Surfaces/PrimarySurface.h" + +namespace +{ + struct ContextInfo + { + D3DKMT_HANDLE device; + + ContextInfo() : device(0) {} + }; + + struct DeviceInfo + { + D3DKMT_HANDLE adapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID vidPnSourceId; + + DeviceInfo() : adapter(0), vidPnSourceId(D3DDDI_ID_UNINITIALIZED) {} + }; + + std::map g_contexts; + std::map g_devices; + + NTSTATUS APIENTRY createDevice(D3DKMT_CREATEDEVICE* pData) + { + Compat::LogEnter("D3DKMTCreateDevice", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTCreateDevice)(pData); + if (SUCCEEDED(result)) + { + g_devices[pData->hDevice].adapter = pData->hAdapter; + + D3DKMT_SETQUEUEDLIMIT limit = {}; + limit.hDevice = pData->hDevice; + limit.Type = D3DKMT_SET_QUEUEDLIMIT_PRESENT; + limit.QueuedPresentLimit = 1; + CALL_ORIG_FUNC(D3DKMTSetQueuedLimit)(&limit); + } + Compat::LogLeave("D3DKMTCreateDevice", pData) << result; + return result; + } + + NTSTATUS APIENTRY createContext(D3DKMT_CREATECONTEXT* pData) + { + Compat::LogEnter("D3DKMTCreateContext", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTCreateContext)(pData); + if (SUCCEEDED(result)) + { + g_contexts[pData->hContext].device = pData->hDevice; + } + Compat::LogLeave("D3DKMTCreateContext", pData) << result; + return result; + } + + NTSTATUS APIENTRY createContextVirtual(D3DKMT_CREATECONTEXTVIRTUAL* pData) + { + Compat::LogEnter("D3DKMTCreateContextVirtual", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTCreateContextVirtual)(pData); + if (SUCCEEDED(result)) + { + g_contexts[pData->hContext].device = pData->hDevice; + } + Compat::LogLeave("D3DKMTCreateContextVirtual", pData) << result; + return result; + } + + NTSTATUS APIENTRY destroyContext(const D3DKMT_DESTROYCONTEXT* pData) + { + Compat::LogEnter("D3DKMTDestroyContext", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTDestroyContext)(pData); + if (SUCCEEDED(result)) + { + g_contexts.erase(pData->hContext); + } + Compat::LogLeave("D3DKMTDestroyContext", pData) << result; + return result; + } + + NTSTATUS APIENTRY destroyDevice(const D3DKMT_DESTROYDEVICE* pData) + { + Compat::LogEnter("D3DKMTDestroyDevice", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTDestroyDevice)(pData); + if (SUCCEEDED(result)) + { + g_devices.erase(pData->hDevice); + } + Compat::LogLeave("D3DKMTDestroyDevice", pData) << result; + return result; + } + + NTSTATUS APIENTRY present(D3DKMT_PRESENT* pData) + { + Compat::LogEnter("D3DKMTPresent", pData); + + static UINT presentCount = 0; + ++presentCount; + pData->Flags.PresentCountValid = 1; + pData->PresentCount = presentCount; + + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTPresent)(pData); + if (SUCCEEDED(result) && + 1 == DDraw::PrimarySurface::getDesc().dwBackBufferCount && + pData->Flags.Flip && pData->FlipInterval != D3DDDI_FLIPINTERVAL_IMMEDIATE) + { + auto contextIt = g_contexts.find(pData->hContext); + auto deviceIt = (contextIt != g_contexts.end()) + ? g_devices.find(contextIt->second.device) + : g_devices.find(pData->hDevice); + if (deviceIt != g_devices.end()) + { + D3DKMT_WAITFORVERTICALBLANKEVENT vbEvent = {}; + vbEvent.hAdapter = deviceIt->second.adapter; + vbEvent.hDevice = deviceIt->first; + vbEvent.VidPnSourceId = deviceIt->second.vidPnSourceId; + + D3DKMT_GETDEVICESTATE deviceState = {}; + deviceState.hDevice = deviceIt->first; + deviceState.StateType = D3DKMT_DEVICESTATE_PRESENT; + deviceState.PresentState.VidPnSourceId = deviceIt->second.vidPnSourceId; + NTSTATUS stateResult = D3DKMTGetDeviceState(&deviceState); + while (SUCCEEDED(stateResult) && + presentCount != deviceState.PresentState.PresentStats.PresentCount) + { + if (FAILED(D3DKMTWaitForVerticalBlankEvent(&vbEvent))) + { + Sleep(1); + } + stateResult = D3DKMTGetDeviceState(&deviceState); + } + } + } + + Compat::LogLeave("D3DKMTPresent", pData) << result; + return result; + } + + NTSTATUS APIENTRY queryAdapterInfo(const D3DKMT_QUERYADAPTERINFO* pData) + { + Compat::LogEnter("D3DKMTQueryAdapterInfo", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTQueryAdapterInfo)(pData); + if (SUCCEEDED(result) && KMTQAITYPE_UMDRIVERNAME == pData->Type) + { + auto info = static_cast(pData->pPrivateDriverData); + D3dDdi::onUmdFileNameQueried(info->UmdFileName); + } + Compat::LogLeave("D3DKMTQueryAdapterInfo", pData) << result; + return result; + } + + NTSTATUS APIENTRY setQueuedLimit(const D3DKMT_SETQUEUEDLIMIT* pData) + { + Compat::LogEnter("D3DKMTSetQueuedLimit", pData); + if (D3DKMT_SET_QUEUEDLIMIT_PRESENT == pData->Type) + { + const UINT origLimit = pData->QueuedPresentLimit; + const_cast(pData)->QueuedPresentLimit = 1; + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTSetQueuedLimit)(pData); + const_cast(pData)->QueuedPresentLimit = origLimit; + Compat::LogLeave("D3DKMTSetQueuedLimit", pData) << result; + return result; + } + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTSetQueuedLimit)(pData); + Compat::LogLeave("D3DKMTSetQueuedLimit", pData) << result; + return result; + } + + void processSetVidPnSourceOwner(const D3DKMT_SETVIDPNSOURCEOWNER* pData) + { + auto& vidPnSourceId = g_devices[pData->hDevice].vidPnSourceId; + for (UINT i = 0; i < pData->VidPnSourceCount; ++i) + { + if (D3DKMT_VIDPNSOURCEOWNER_UNOWNED != pData->pType[i]) + { + vidPnSourceId = pData->pVidPnSourceId[i]; + return; + } + } + vidPnSourceId = D3DDDI_ID_UNINITIALIZED; + } + + NTSTATUS APIENTRY setVidPnSourceOwner(const D3DKMT_SETVIDPNSOURCEOWNER* pData) + { + Compat::LogEnter("D3DKMTSetVidPnSourceOwner", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTSetVidPnSourceOwner)(pData); + if (SUCCEEDED(result)) + { + processSetVidPnSourceOwner(pData); + } + Compat::LogLeave("D3DKMTSetVidPnSourceOwner", pData) << result; + return result; + } + + NTSTATUS APIENTRY setVidPnSourceOwner1(const D3DKMT_SETVIDPNSOURCEOWNER1* pData) + { + Compat::LogEnter("D3DKMTSetVidPnSourceOwner1", pData); + NTSTATUS result = CALL_ORIG_FUNC(D3DKMTSetVidPnSourceOwner1)(pData); + if (SUCCEEDED(result)) + { + processSetVidPnSourceOwner(&pData->Version0); + } + Compat::LogLeave("D3DKMTSetVidPnSourceOwner1", pData) << result; + return result; + } +} + +namespace D3dDdi +{ + namespace KernelModeThunks + { + void installHooks() + { + HOOK_FUNCTION(gdi32, D3DKMTCreateContext, createContext); + HOOK_FUNCTION(gdi32, D3DKMTCreateContextVirtual, createContextVirtual); + HOOK_FUNCTION(gdi32, D3DKMTCreateDevice, createDevice); + HOOK_FUNCTION(gdi32, D3DKMTDestroyContext, destroyContext); + HOOK_FUNCTION(gdi32, D3DKMTDestroyDevice, destroyDevice); + HOOK_FUNCTION(gdi32, D3DKMTQueryAdapterInfo, queryAdapterInfo); + HOOK_FUNCTION(gdi32, D3DKMTPresent, present); + HOOK_FUNCTION(gdi32, D3DKMTSetQueuedLimit, setQueuedLimit); + HOOK_FUNCTION(gdi32, D3DKMTSetVidPnSourceOwner, setVidPnSourceOwner); + HOOK_FUNCTION(gdi32, D3DKMTSetVidPnSourceOwner1, setVidPnSourceOwner1); + } + } +} diff --git a/DDrawCompat/D3dDdi/KernelModeThunks.h b/DDrawCompat/D3dDdi/KernelModeThunks.h new file mode 100644 index 0000000..9c49692 --- /dev/null +++ b/DDrawCompat/D3dDdi/KernelModeThunks.h @@ -0,0 +1,11 @@ +#pragma once + +#include "D3dDdi/Log/KernelModeThunksLog.h" + +namespace D3dDdi +{ + namespace KernelModeThunks + { + void installHooks(); + } +} diff --git a/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.cpp b/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.cpp new file mode 100644 index 0000000..eb99430 --- /dev/null +++ b/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.cpp @@ -0,0 +1,38 @@ +#include "Common/Log.h" +#include "D3dDdi/Log/AdapterFuncsLog.h" + +std::ostream& operator<<(std::ostream& os, const D3DDDI_ALLOCATIONLIST& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hAllocation) + << Compat::hex(data.Value); +} + +std::ostream& operator<<(std::ostream& os, const D3DDDI_PATCHLOCATIONLIST& data) +{ + return Compat::LogStruct(os) + << data.AllocationIndex + << Compat::hex(data.Value) + << Compat::hex(data.DriverId) + << Compat::hex(data.AllocationOffset) + << Compat::hex(data.PatchOffset) + << Compat::hex(data.SplitOffset); +} + +std::ostream& operator<<(std::ostream& os, const D3DDDIARG_CREATEDEVICE& data) +{ + return Compat::LogStruct(os) + << data.hDevice + << data.Interface + << data.Version + << data.pCallbacks + << data.pCommandBuffer + << data.CommandBufferSize + << data.pAllocationList + << data.AllocationListSize + << data.pPatchLocationList + << data.PatchLocationListSize + << data.pDeviceFuncs + << Compat::hex(data.Flags.Value) + << Compat::hex(data.CommandBuffer); +} diff --git a/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h b/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h new file mode 100644 index 0000000..de05b50 --- /dev/null +++ b/DDrawCompat/D3dDdi/Log/AdapterFuncsLog.h @@ -0,0 +1,12 @@ +#pragma once + +#define CINTERFACE + +#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.cpp b/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.cpp index 5a9d602..9757ba0 100644 --- a/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.cpp +++ b/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.cpp @@ -76,6 +76,21 @@ std::ostream& operator<<(std::ostream& os, const D3DDDICB_LOCK2& data) << data.pData; } +std::ostream& operator<<(std::ostream& os, const D3DDDICB_PRESENT& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hSrcAllocation) + << Compat::hex(data.hDstAllocation) + << data.hContext + << data.BroadcastContextCount + << Compat::array(data.BroadcastContext, data.BroadcastContextCount) + << Compat::hex(data.BroadcastSrcAllocation) + << Compat::hex(data.BroadcastDstAllocation) + << data.PrivateDriverDataSize + << data.pPrivateDriverData + << static_cast(data.bOptimizeForComposition); +} + std::ostream& operator<<(std::ostream& os, const D3DDDICB_UNLOCK& data) { return Compat::LogStruct(os) diff --git a/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h b/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h index a286eed..e307640 100644 --- a/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h +++ b/DDrawCompat/D3dDdi/Log/DeviceCallbacksLog.h @@ -14,5 +14,6 @@ std::ostream& operator<<(std::ostream& os, const D3DDDICB_DEALLOCATE& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_DEALLOCATE2& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_LOCK& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_LOCK2& data); +std::ostream& operator<<(std::ostream& os, const D3DDDICB_PRESENT& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_UNLOCK& data); std::ostream& operator<<(std::ostream& os, const D3DDDICB_UNLOCK2& data); diff --git a/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.cpp b/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.cpp new file mode 100644 index 0000000..c887004 --- /dev/null +++ b/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.cpp @@ -0,0 +1,116 @@ +#include "Common/Log.h" +#include "D3dDdi/Log/KernelModeThunksLog.h" + +std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATECONTEXT& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hDevice) + << data.NodeOrdinal + << data.EngineAffinity + << Compat::hex(data.Flags.Value) + << data.pPrivateDriverData + << data.PrivateDriverDataSize + << data.ClientHint + << Compat::hex(data.hContext) + << data.pCommandBuffer + << data.CommandBufferSize + << Compat::array(data.pAllocationList, data.AllocationListSize) + << data.AllocationListSize + << Compat::array(data.pPatchLocationList, data.PatchLocationListSize) + << data.PatchLocationListSize + << Compat::hex(data.CommandBuffer); +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATECONTEXTVIRTUAL& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hDevice) + << data.NodeOrdinal + << data.EngineAffinity + << Compat::hex(data.Flags.Value) + << data.pPrivateDriverData + << data.PrivateDriverDataSize + << data.ClientHint + << Compat::hex(data.hContext); +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATEDEVICE& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hAdapter) + << Compat::hex(*reinterpret_cast(&data.Flags)) + << Compat::hex(data.hDevice) + << data.pCommandBuffer + << data.CommandBufferSize + << Compat::array(data.pAllocationList, data.AllocationListSize) + << data.AllocationListSize + << Compat::array(data.pPatchLocationList, data.PatchLocationListSize) + << data.PatchLocationListSize; +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_DESTROYCONTEXT& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hContext); +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_DESTROYDEVICE& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hDevice); +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_PRESENT& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hDevice) + << data.hWindow + << data.VidPnSourceId + << Compat::hex(data.hSource) + << Compat::hex(data.hDestination) + << Compat::hex(data.Color) + << data.DstRect + << data.SrcRect + << data.SubRectCnt + << Compat::array(data.pSrcSubRects, data.SubRectCnt) + << data.PresentCount + << data.FlipInterval + << Compat::hex(data.Flags.Value) + << data.BroadcastContextCount + << Compat::hex(Compat::array(data.BroadcastContext, data.BroadcastContextCount)) + << data.PresentLimitSemaphore + << data.PresentHistoryToken + << data.pPresentRegions + << Compat::hex(data.hAdapter) + << data.Duration + << Compat::hex(Compat::array(data.BroadcastSrcAllocation, data.BroadcastContextCount)) + << Compat::hex(Compat::array(data.BroadcastDstAllocation, data.BroadcastContextCount)) + << data.PrivateDriverDataSize + << data.pPrivateDriverData + << static_cast(data.bOptimizeForComposition); +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_SETQUEUEDLIMIT& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hDevice) + << data.Type + << data.VidPnSourceId + << data.QueuedPendingFlipLimit; +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_SETVIDPNSOURCEOWNER& data) +{ + return Compat::LogStruct(os) + << Compat::hex(data.hDevice) + << Compat::array(data.pType, data.VidPnSourceCount) + << Compat::array(data.pVidPnSourceId, data.VidPnSourceCount) + << data.VidPnSourceCount; +} + +std::ostream& operator<<(std::ostream& os, const D3DKMT_SETVIDPNSOURCEOWNER1& data) +{ + return Compat::LogStruct(os) + << data.Version0 + << Compat::hex(data.Flags.Value); +} diff --git a/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h b/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h new file mode 100644 index 0000000..f2af804 --- /dev/null +++ b/DDrawCompat/D3dDdi/Log/KernelModeThunksLog.h @@ -0,0 +1,19 @@ +#pragma once + +#define CINTERFACE + +#include + +#include +#include +#include <../km/d3dkmthk.h> + +std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATECONTEXT& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATECONTEXTVIRTUAL& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_CREATEDEVICE& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_DESTROYCONTEXT& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_DESTROYDEVICE& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_PRESENT& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_SETQUEUEDLIMIT& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_SETVIDPNSOURCEOWNER& data); +std::ostream& operator<<(std::ostream& os, const D3DKMT_SETVIDPNSOURCEOWNER1& data); diff --git a/DDrawCompat/DDraw/RealPrimarySurface.cpp b/DDrawCompat/DDraw/RealPrimarySurface.cpp index 3314521..bc49532 100644 --- a/DDrawCompat/DDraw/RealPrimarySurface.cpp +++ b/DDrawCompat/DDraw/RealPrimarySurface.cpp @@ -213,7 +213,7 @@ namespace DDraw desc.dwSize = sizeof(desc); desc.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; - desc.dwBackBufferCount = 2; + desc.dwBackBufferCount = 1; CompatPtr::TCreatedSurface> surface; HRESULT result = dd->CreateSurface(&dd, &desc, &surface.getRef(), nullptr); diff --git a/DDrawCompat/DDrawCompat.vcxproj b/DDrawCompat/DDrawCompat.vcxproj index e368c76..d990e1f 100644 --- a/DDrawCompat/DDrawCompat.vcxproj +++ b/DDrawCompat/DDrawCompat.vcxproj @@ -169,9 +169,12 @@ + + + @@ -233,9 +236,12 @@ + + + diff --git a/DDrawCompat/DDrawCompat.vcxproj.filters b/DDrawCompat/DDrawCompat.vcxproj.filters index ffec786..2173d79 100644 --- a/DDrawCompat/DDrawCompat.vcxproj.filters +++ b/DDrawCompat/DDrawCompat.vcxproj.filters @@ -291,6 +291,15 @@ Header Files\D3dDdi + + Header Files\D3dDdi\Log + + + Header Files\D3dDdi + + + Header Files\D3dDdi\Log + @@ -440,6 +449,15 @@ Source Files\D3dDdi + + Source Files\D3dDdi\Log + + + Source Files\D3dDdi + + + Source Files\D3dDdi\Log +