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 +