Refactored adapter and device references

DDrawCompat/D3dDdi/Adapter.cpp

@@ -0,0 +1,43 @@
+#include "D3dDdi/Adapter.h"
+#include "D3dDdi/AdapterFuncs.h"
+
+namespace D3dDdi
+{
+	Adapter::Adapter(HANDLE adapter, HMODULE module)
+		: m_adapter(adapter)
+		, m_module(module)
+		, m_d3dExtendedCaps{}
+	{
+		if (m_adapter)
+		{
+			D3DDDIARG_GETCAPS getCaps = {};
+			getCaps.Type = D3DDDICAPS_GETD3D7CAPS;
+			getCaps.pData = &m_d3dExtendedCaps;
+			getCaps.DataSize = sizeof(m_d3dExtendedCaps);
+			D3dDdi::AdapterFuncs::s_origVtables.at(adapter).pfnGetCaps(adapter, &getCaps);
+		}
+	}
+
+	void Adapter::add(HANDLE adapter, HMODULE module)
+	{
+		s_adapters.emplace(adapter, Adapter(adapter, module));
+	}
+
+	Adapter& Adapter::get(HANDLE adapter)
+	{
+		auto it = s_adapters.find(adapter);
+		if (it != s_adapters.end())
+		{
+			return it->second;
+		}
+
+		return s_adapters.emplace(adapter, Adapter(adapter, nullptr)).first->second;
+	}
+
+	void Adapter::remove(HANDLE adapter)
+	{
+		s_adapters.erase(adapter);
+	}
+
+	std::map<HANDLE, Adapter> Adapter::s_adapters;
+}

DDrawCompat/D3dDdi/Adapter.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <map>
+
+#include <d3d.h>
+#include <d3dnthal.h>
+#include <d3dumddi.h>
+
+namespace D3dDdi
+{
+	class Adapter
+	{
+	public:
+		Adapter(HANDLE adapter, HMODULE module);
+
+		const D3DNTHAL_D3DEXTENDEDCAPS& getD3dExtendedCaps() const { return m_d3dExtendedCaps; }
+		HANDLE getHandle() const { return m_adapter; }
+		HMODULE getModule() const { return m_module; }
+
+		static void add(HANDLE adapter, HMODULE module);
+		static Adapter& get(HANDLE adapter);
+		static void remove(HANDLE adapter);
+
+	private:
+		HANDLE m_adapter;
+		HMODULE m_module;
+		D3DNTHAL_D3DEXTENDEDCAPS m_d3dExtendedCaps;
+
+		static std::map<HANDLE, Adapter> s_adapters;
+	};
+}

DDrawCompat/D3dDdi/AdapterFuncs.cpp

@@ -1,22 +1,19 @@
 #include <map>
 
+#include "D3dDdi/Adapter.h"
 #include "D3dDdi/AdapterFuncs.h"
 #include "D3dDdi/DeviceCallbacks.h"
 #include "D3dDdi/DeviceFuncs.h"
 
 namespace
 {
-	std::map<HANDLE, D3DNTHAL_D3DEXTENDEDCAPS> g_d3dExtendedCaps;
-	std::map<HANDLE, HMODULE> g_adapterModule;
-
 	HRESULT APIENTRY closeAdapter(HANDLE hAdapter)
 	{
 		HRESULT result = D3dDdi::AdapterFuncs::s_origVtables.at(hAdapter).pfnCloseAdapter(hAdapter);
 		if (SUCCEEDED(result))
 		{
 			D3dDdi::AdapterFuncs::s_origVtables.erase(hAdapter);
-			g_d3dExtendedCaps.erase(hAdapter);
-			g_adapterModule.erase(hAdapter);
+			D3dDdi::Adapter::remove(hAdapter);
 		}
 		return result;
 	}
@@ -29,7 +26,7 @@ namespace
 		if (SUCCEEDED(result))
 		{
 			D3dDdi::DeviceFuncs::hookVtable(
-				g_adapterModule[hAdapter], pCreateData->hDevice, pCreateData->pDeviceFuncs);
+				D3dDdi::Adapter::get(hAdapter).getModule(), pCreateData->hDevice, pCreateData->pDeviceFuncs);
 			D3dDdi::DeviceFuncs::onCreateDevice(hAdapter, pCreateData->hDevice);
 		}
 		return result;
@@ -48,24 +45,9 @@ namespace
 
 namespace D3dDdi
 {
-	const D3DNTHAL_D3DEXTENDEDCAPS& AdapterFuncs::getD3dExtendedCaps(HANDLE adapter)
+	void AdapterFuncs::onOpenAdapter(HANDLE adapter, HMODULE module)
 	{
-		static D3DNTHAL_D3DEXTENDEDCAPS emptyCaps = {};
-		auto it = g_d3dExtendedCaps.find(adapter);
-		return it != g_d3dExtendedCaps.end() ? it->second : emptyCaps;
-	}
-
-	void AdapterFuncs::onOpenAdapter(HMODULE module, HANDLE adapter)
-	{
-		D3DNTHAL_D3DEXTENDEDCAPS d3dExtendedCaps = {};
-		D3DDDIARG_GETCAPS getCaps = {};
-		getCaps.Type = D3DDDICAPS_GETD3D7CAPS;
-		getCaps.pData = &d3dExtendedCaps;
-		getCaps.DataSize = sizeof(d3dExtendedCaps);
-
-		D3dDdi::AdapterFuncs::s_origVtables.at(adapter).pfnGetCaps(adapter, &getCaps);
-		g_d3dExtendedCaps[adapter] = d3dExtendedCaps;
-		g_adapterModule[adapter] = module;
+		Adapter::add(adapter, module);
 	}
 
 	void AdapterFuncs::setCompatVtable(D3DDDI_ADAPTERFUNCS& vtable)

DDrawCompat/D3dDdi/AdapterFuncs.h

@@ -13,8 +13,7 @@ namespace D3dDdi
 	class AdapterFuncs : public D3dDdiVtable<D3DDDI_ADAPTERFUNCS>
 	{
 	public:
-		static const D3DNTHAL_D3DEXTENDEDCAPS& getD3dExtendedCaps(HANDLE adapter);
-		static void onOpenAdapter(HMODULE module, HANDLE adapter);
+		static void onOpenAdapter(HANDLE adapter, HMODULE module);
 		static void setCompatVtable(D3DDDI_ADAPTERFUNCS& vtable);
 	};
 }

DDrawCompat/D3dDdi/Device.cpp

@@ -1,7 +1,7 @@
 #include <d3d.h>
 #include <../km/d3dkmthk.h>
 
-#include "D3dDdi/AdapterFuncs.h"
+#include "D3dDdi/Adapter.h"
 #include "D3dDdi/Device.h"
 #include "D3dDdi/DeviceFuncs.h"
 #include "D3dDdi/KernelModeThunks.h"
@@ -99,8 +99,8 @@ namespace D3dDdi
 	}
 
 	Device::Device(HANDLE adapter, HANDLE device)
-		: m_origVtable(&DeviceFuncs::s_origVtables.at(device))
-		, m_adapter(adapter)
+		: m_origVtable(DeviceFuncs::s_origVtables.at(device))
+		, m_adapter(Adapter::get(adapter))
 		, m_device(device)
 		, m_sharedPrimary(nullptr)
 	{
@@ -123,19 +123,19 @@ namespace D3dDdi
 			return it->second.bltTo(data);
 		}
 
-		return m_origVtable->pfnBlt(m_device, &data);
+		return m_origVtable.pfnBlt(m_device, &data);
 	}
 
 	HRESULT Device::clear(const D3DDDIARG_CLEAR& data, UINT numRect, const RECT* rect)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		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)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE, data.hResource, data.SubResourceIndex);
-		return m_origVtable->pfnColorFill(m_device, &data);
+		return m_origVtable.pfnColorFill(m_device, &data);
 	}
 
 	template <typename CreateResourceArg, typename CreateResourceFunc>
@@ -161,8 +161,7 @@ namespace D3dDdi
 
 		if (SUCCEEDED(result))
 		{
-			m_oversizedResources.emplace(data.hResource,
-				OversizedResource(*m_origVtable, m_adapter, m_device, data.Format, origSurfList[0]));
+			m_oversizedResources.emplace(data.hResource, OversizedResource(*this, data.Format, origSurfList[0]));
 		}
 
 		return result;
@@ -175,10 +174,9 @@ namespace D3dDdi
 		if (D3DDDIPOOL_SYSTEMMEM == data.Pool &&
 			(isOffScreenPlain || data.Flags.Texture) &&
 			OversizedResource::isSupportedFormat(data.Format) &&
-			1 == data.SurfCount &&
-			m_adapter)
+			1 == data.SurfCount)
 		{
-			const auto& caps = AdapterFuncs::getD3dExtendedCaps(m_adapter);
+			const auto& caps = m_adapter.getD3dExtendedCaps();
 			const auto& surfaceInfo = data.pSurfList[0];
 			if (0 != caps.dwMaxTextureWidth && surfaceInfo.Width > caps.dwMaxTextureWidth ||
 				0 != caps.dwMaxTextureHeight && surfaceInfo.Height > caps.dwMaxTextureHeight)
@@ -196,7 +194,7 @@ namespace D3dDdi
 		if (SUCCEEDED(result) && data.Flags.RenderTarget && !data.Flags.Primary && isVidMemPool(data.Pool))
 		{
 			m_renderTargetResources.emplace(data.hResource,
-				RenderTargetResource(*m_origVtable, m_device, data.hResource, data.Format, data.SurfCount));
+				RenderTargetResource(*this, data.hResource, data.Format, data.SurfCount));
 		}
 
 		return result;
@@ -204,12 +202,12 @@ namespace D3dDdi
 
 	HRESULT Device::createResource(D3DDDIARG_CREATERESOURCE& data)
 	{
-		return createResourceImpl(data, m_origVtable->pfnCreateResource);
+		return createResourceImpl(data, m_origVtable.pfnCreateResource);
 	}
 
 	HRESULT Device::createResource2(D3DDDIARG_CREATERESOURCE2& data)
 	{
-		return createResourceImpl(data, m_origVtable->pfnCreateResource2);
+		return createResourceImpl(data, m_origVtable.pfnCreateResource2);
 	}
 
 	HRESULT Device::destroyResource(HANDLE resource)
@@ -219,7 +217,7 @@ namespace D3dDdi
 			D3DKMTReleaseProcessVidPnSourceOwners(GetCurrentProcess());
 		}
 
-		HRESULT result = m_origVtable->pfnDestroyResource(m_device, resource);
+		HRESULT result = m_origVtable.pfnDestroyResource(m_device, resource);
 		if (SUCCEEDED(result))
 		{
 			m_oversizedResources.erase(resource);
@@ -242,40 +240,40 @@ namespace D3dDdi
 	HRESULT Device::drawIndexedPrimitive(const D3DDDIARG_DRAWINDEXEDPRIMITIVE& data)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		return m_origVtable->pfnDrawIndexedPrimitive(m_device, &data);
+		return m_origVtable.pfnDrawIndexedPrimitive(m_device, &data);
 	}
 
 	HRESULT Device::drawIndexedPrimitive2(const D3DDDIARG_DRAWINDEXEDPRIMITIVE2& data,
 		UINT indicesSize, const void* indexBuffer, const UINT* flagBuffer)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		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)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		return m_origVtable->pfnDrawPrimitive(m_device, &data, flagBuffer);
+		return m_origVtable.pfnDrawPrimitive(m_device, &data, flagBuffer);
 	}
 
 	HRESULT Device::drawPrimitive2(const D3DDDIARG_DRAWPRIMITIVE2& data)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		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,
 		const FLOAT* patch)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		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,
 		const FLOAT* patch)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_WRITE);
-		return m_origVtable->pfnDrawTriPatch(m_device, &data, info, patch);
+		return m_origVtable.pfnDrawTriPatch(m_device, &data, info, patch);
 	}
 
 	HRESULT Device::lock(D3DDDIARG_LOCK& data)
@@ -294,12 +292,12 @@ namespace D3dDdi
 			}
 			return result;
 		}
-		return m_origVtable->pfnLock(m_device, &data);
+		return m_origVtable.pfnLock(m_device, &data);
 	}
 
 	HRESULT Device::openResource(D3DDDIARG_OPENRESOURCE& data)
 	{
-		HRESULT result = m_origVtable->pfnOpenResource(m_device, &data);
+		HRESULT result = m_origVtable.pfnOpenResource(m_device, &data);
 		if (SUCCEEDED(result) && data.Flags.Fullscreen)
 		{
 			m_sharedPrimary = data.hResource;
@@ -310,7 +308,7 @@ namespace D3dDdi
 	HRESULT Device::present(const D3DDDIARG_PRESENT& data)
 	{
 		RenderGuard renderGuard(*this, Gdi::ACCESS_READ, data.hSrcResource, data.SrcSubResourceIndex);
-		return m_origVtable->pfnPresent(m_device, &data);
+		return m_origVtable.pfnPresent(m_device, &data);
 	}
 
 	HRESULT Device::present1(D3DDDIARG_PRESENT1& data)
@@ -328,21 +326,21 @@ namespace D3dDdi
 			prepareForRendering(data.phSrcResources[i].hResource, data.phSrcResources[i].SubResourceIndex);
 		}
 
-		return m_origVtable->pfnPresent1(m_device, &data);
+		return m_origVtable.pfnPresent1(m_device, &data);
 	}
 
 	HRESULT Device::texBlt(const D3DDDIARG_TEXBLT& data)
 	{
 		RenderGuard dstRenderGuard(*this, Gdi::ACCESS_WRITE, data.hDstResource);
 		RenderGuard srcRenderGuard(*this, Gdi::ACCESS_READ, data.hSrcResource);
-		return m_origVtable->pfnTexBlt(m_device, &data);
+		return m_origVtable.pfnTexBlt(m_device, &data);
 	}
 
 	HRESULT Device::texBlt1(const D3DDDIARG_TEXBLT1& data)
 	{
 		RenderGuard dstRenderGuard(*this, Gdi::ACCESS_WRITE, data.hDstResource);
 		RenderGuard srcRenderGuard(*this, Gdi::ACCESS_READ, data.hSrcResource);
-		return m_origVtable->pfnTexBlt1(m_device, &data);
+		return m_origVtable.pfnTexBlt1(m_device, &data);
 	}
 
 	HRESULT Device::unlock(const D3DDDIARG_UNLOCK& data)
@@ -353,7 +351,7 @@ namespace D3dDdi
 		{
 			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)
@@ -363,9 +361,9 @@ namespace D3dDdi
 			D3DDDIARG_WINFO wInfo = {};
 			wInfo.WNear = 0.0f;
 			wInfo.WFar = 1.0f;
-			return m_origVtable->pfnUpdateWInfo(m_device, &wInfo);
+			return m_origVtable.pfnUpdateWInfo(m_device, &wInfo);
 		}
-		return m_origVtable->pfnUpdateWInfo(m_device, &data);
+		return m_origVtable.pfnUpdateWInfo(m_device, &data);
 	}
 
 	void Device::prepareForRendering(RenderTargetResource& resource, UINT subResourceIndex)
@@ -395,6 +393,27 @@ namespace D3dDdi
 		}
 	}
 
+	void Device::add(HANDLE adapter, HANDLE device)
+	{
+		s_devices.emplace(device, Device(adapter, device));
+	}
+
+	Device& Device::get(HANDLE device)
+	{
+		auto it = s_devices.find(device);
+		if (it != s_devices.end())
+		{
+			return it->second;
+		}
+
+		return s_devices.emplace(device, Device(nullptr, device)).first->second;
+	}
+
+	void Device::remove(HANDLE device)
+	{
+		s_devices.erase(device);
+	}
+
 	void Device::setGdiResourceHandle(HANDLE resource)
 	{
 		g_gdiResourceHandle = resource;
@@ -404,4 +423,6 @@ namespace D3dDdi
 	{
 		g_isReadOnlyGdiLockEnabled = enable;
 	}
+
+	std::map<HANDLE, Device> Device::s_devices;
 }

DDrawCompat/D3dDdi/Device.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <map>
-#include <set>
 
 #include <d3d.h>
 #include <d3dnthal.h>
@@ -14,11 +13,11 @@ namespace D3dDdi
 {
 	UINT getBytesPerPixel(D3DDDIFORMAT format);
 
+	class Adapter;
+
 	class Device
 	{
 	public:
-		Device(HANDLE adapter, HANDLE device);
-
 		HRESULT blt(const D3DDDIARG_BLT& data);
 		HRESULT clear(const D3DDDIARG_CLEAR& data, UINT numRect, const RECT* rect);
 		HRESULT colorFill(const D3DDDIARG_COLORFILL& data);
@@ -43,13 +42,23 @@ namespace D3dDdi
 		HRESULT unlock(const D3DDDIARG_UNLOCK& data);
 		HRESULT updateWInfo(const D3DDDIARG_WINFO& data);
 
+		Adapter& getAdapter() const { return m_adapter; }
+		HANDLE getHandle() const { return m_device; }
+		const D3DDDI_DEVICEFUNCS& getOrigVtable() const { return m_origVtable; }
+
 		void prepareForRendering(HANDLE resource, UINT subResourceIndex = UINT_MAX);
 		void prepareForRendering();
 
+		static void add(HANDLE adapter, HANDLE device);
+		static Device& get(HANDLE device);
+		static void remove(HANDLE device);
+
 		static void setGdiResourceHandle(HANDLE resource);
 		static void setReadOnlyGdiLock(bool enable);
 
 	private:
+		Device(HANDLE adapter, HANDLE device);
+
 		template <typename CreateResourceArg, typename CreateResourceFunc>
 		HRESULT createOversizedResource(
 			CreateResourceArg& data,
@@ -61,12 +70,14 @@ namespace D3dDdi
 
 		void prepareForRendering(RenderTargetResource& resource, UINT subResourceIndex = UINT_MAX);
 
-		const D3DDDI_DEVICEFUNCS* m_origVtable;
-		HANDLE m_adapter;
+		const D3DDDI_DEVICEFUNCS& m_origVtable;
+		Adapter& m_adapter;
 		HANDLE m_device;
 		std::map<HANDLE, OversizedResource> m_oversizedResources;
 		std::map<HANDLE, RenderTargetResource> m_renderTargetResources;
 		std::map<HANDLE, RenderTargetResource&> m_lockedRenderTargetResources;
 		HANDLE m_sharedPrimary;
+
+		static std::map<HANDLE, Device> s_devices;
 	};
 }

DDrawCompat/D3dDdi/DeviceFuncs.cpp

@@ -1,27 +1,12 @@
-#include <map>
-
 #include "D3dDdi/Device.h"
 #include "D3dDdi/DeviceFuncs.h"
 
 namespace
 {
-	std::map<HANDLE, D3dDdi::Device> g_devices;
-
-	D3dDdi::Device& getDevice(HANDLE device)
-	{
-		auto it = g_devices.find(device);
-		if (it != g_devices.end())
-		{
-			return it->second;
-		}
-
-		return g_devices.emplace(device, D3dDdi::Device(nullptr, device)).first->second;
-	}
-
 	template <typename DeviceMethodPtr, DeviceMethodPtr deviceMethod, typename Arg, typename... Params>
 	HRESULT WINAPI deviceFunc(HANDLE device, Arg* data, Params... params)
 	{
-		return (getDevice(device).*deviceMethod)(*data, params...);
+		return (D3dDdi::Device::get(device).*deviceMethod)(*data, params...);
 	}
 
 	HRESULT APIENTRY destroyDevice(HANDLE hDevice)
@@ -30,14 +15,14 @@ namespace
 		if (SUCCEEDED(result))
 		{
 			D3dDdi::DeviceFuncs::s_origVtables.erase(hDevice);
-			g_devices.erase(hDevice);
+			D3dDdi::Device::remove(hDevice);
 		}
 		return result;
 	}
 
 	HRESULT APIENTRY destroyResource(HANDLE hDevice, HANDLE hResource)
 	{
-		return getDevice(hDevice).destroyResource(hResource);
+		return D3dDdi::Device::get(hDevice).destroyResource(hResource);
 	}
 }
 
@@ -47,7 +32,7 @@ namespace D3dDdi
 {
 	void DeviceFuncs::onCreateDevice(HANDLE adapter, HANDLE device)
 	{
-		g_devices.emplace(device, Device(adapter, device));
+		Device::add(adapter, device);
 	}
 
 	void DeviceFuncs::setCompatVtable(D3DDDI_DEVICEFUNCS& vtable)

DDrawCompat/D3dDdi/Hooks.cpp

@@ -60,7 +60,7 @@ namespace
 			}
 			g_ddiVersion = min(pOpenData->Version, pOpenData->DriverVersion);
 			D3dDdi::AdapterFuncs::hookVtable(g_hookedUmdModule, pOpenData->hAdapter, pOpenData->pAdapterFuncs);
-			D3dDdi::AdapterFuncs::onOpenAdapter(g_hookedUmdModule, pOpenData->hAdapter);
+			D3dDdi::AdapterFuncs::onOpenAdapter(pOpenData->hAdapter, g_hookedUmdModule);
 		}
 		return LOG_RESULT(result);
 	}

DDrawCompat/D3dDdi/OversizedResource.cpp

@@ -1,16 +1,11 @@
-#include "D3dDdi/AdapterFuncs.h"
+#include "D3dDdi/Adapter.h"
 #include "D3dDdi/Device.h"
-#include "D3dDdi/DeviceFuncs.h"
 #include "D3dDdi/OversizedResource.h"
 
 namespace D3dDdi
 {
-	OversizedResource::OversizedResource(
-		const D3DDDI_DEVICEFUNCS& deviceFuncs, HANDLE adapter, HANDLE device,
-		D3DDDIFORMAT format, const D3DDDI_SURFACEINFO& surfaceInfo)
-		: m_deviceFuncs(deviceFuncs)
-		, m_adapter(adapter)
-		, m_device(device)
+	OversizedResource::OversizedResource(Device& device, D3DDDIFORMAT format, const D3DDDI_SURFACEINFO& surfaceInfo)
+		: m_device(device)
 		, m_format(format)
 		, m_surfaceInfo(surfaceInfo)
 	{
@@ -18,11 +13,11 @@ namespace D3dDdi
 
 	HRESULT OversizedResource::blt(D3DDDIARG_BLT& data, HANDLE& resource, RECT& rect)
 	{
-		const auto& caps = D3dDdi::AdapterFuncs::getD3dExtendedCaps(m_adapter);
+		const auto& caps = m_device.getAdapter().getD3dExtendedCaps();
 		if (rect.right <= static_cast<LONG>(caps.dwMaxTextureWidth) &&
 			rect.bottom <= static_cast<LONG>(caps.dwMaxTextureHeight))
 		{
-			return m_deviceFuncs.pfnBlt(m_device, &data);
+			return m_device.getOrigVtable().pfnBlt(m_device.getHandle(), &data);
 		}
 
 		HANDLE origResource = resource;
@@ -35,13 +30,13 @@ namespace D3dDdi
 			rect = RECT{ 0, 0, rect.right - rect.left, rect.bottom - rect.top };
 		}
 
-		HRESULT result = m_deviceFuncs.pfnBlt(m_device, &data);
+		HRESULT result = m_device.getOrigVtable().pfnBlt(m_device.getHandle(), &data);
 
 		if (bltResource)
 		{
 			resource = origResource;
 			rect = origRect;
-			m_deviceFuncs.pfnDestroyResource(m_device, bltResource);
+			m_device.getOrigVtable().pfnDestroyResource(m_device.getHandle(), bltResource);
 		}
 
 		return result;
@@ -77,13 +72,13 @@ namespace D3dDdi
 		bltResourceData.pSurfList = &bltSurfaceInfo;
 		bltResourceData.SurfCount = 1;
 
-		if (m_deviceFuncs.pfnCreateResource2)
+		if (m_device.getOrigVtable().pfnCreateResource2)
 		{
-			m_deviceFuncs.pfnCreateResource2(m_device, &bltResourceData);
+			m_device.getOrigVtable().pfnCreateResource2(m_device.getHandle(), &bltResourceData);
 		}
 		else
 		{
-			m_deviceFuncs.pfnCreateResource(m_device,
+			m_device.getOrigVtable().pfnCreateResource(m_device.getHandle(),
 				reinterpret_cast<D3DDDIARG_CREATERESOURCE*>(&bltResourceData));
 		}
 		return bltResourceData.hResource;

DDrawCompat/D3dDdi/OversizedResource.h

@@ -5,11 +5,12 @@
 
 namespace D3dDdi
 {
+	class Device;
+
 	class OversizedResource
 	{
 	public:
-		OversizedResource(const D3DDDI_DEVICEFUNCS& deviceFuncs, HANDLE adapter, HANDLE device,
-			D3DDDIFORMAT format, const D3DDDI_SURFACEINFO& surfaceInfo);
+		OversizedResource(Device& device, D3DDDIFORMAT format, const D3DDDI_SURFACEINFO& surfaceInfo);
 
 		HRESULT bltFrom(D3DDDIARG_BLT data);
 		HRESULT bltTo(D3DDDIARG_BLT data);
@@ -20,9 +21,7 @@ namespace D3dDdi
 		HRESULT blt(D3DDDIARG_BLT& data, HANDLE& resource, RECT& rect);
 		HANDLE createBltResource(RECT bltRect);
 
-		const D3DDDI_DEVICEFUNCS& m_deviceFuncs;
-		HANDLE m_adapter;
-		HANDLE m_device;
+		Device& m_device;
 		D3DDDIFORMAT m_format;
 		D3DDDI_SURFACEINFO m_surfaceInfo;
 	};

DDrawCompat/D3dDdi/RenderTargetResource.cpp

@@ -1,13 +1,10 @@
 #include "D3dDdi/Device.h"
-#include "D3dDdi/DeviceFuncs.h"
 #include "D3dDdi/RenderTargetResource.h"
 
 namespace D3dDdi
 {
-	RenderTargetResource::RenderTargetResource(const D3DDDI_DEVICEFUNCS& deviceFuncs,
-		HANDLE device, HANDLE resource, D3DDDIFORMAT format, UINT surfaceCount)
-		: m_deviceFuncs(deviceFuncs)
-		, m_device(device)
+	RenderTargetResource::RenderTargetResource(Device& device, HANDLE resource, D3DDDIFORMAT format, UINT surfaceCount)
+		: m_device(device)
 		, m_resource(resource)
 		, m_bytesPerPixel(getBytesPerPixel(format))
 		, m_subResources(surfaceCount, SubResource(*this))
@@ -18,7 +15,7 @@ namespace D3dDdi
 	{
 		if (data.SubResourceIndex >= m_subResources.size())
 		{
-			return m_deviceFuncs.pfnLock(m_device, &data);
+			return m_device.getOrigVtable().pfnLock(m_device.getHandle(), &data);
 		}
 
 		auto& subResource = m_subResources[data.SubResourceIndex];
@@ -37,7 +34,7 @@ namespace D3dDdi
 
 		const UINT origFlags = data.Flags.Value;
 		data.Flags.Value = 0;
-		const HRESULT result = m_deviceFuncs.pfnLock(m_device, &data);
+		const HRESULT result = m_device.getOrigVtable().pfnLock(m_device.getHandle(), &data);
 		data.Flags.Value = origFlags;
 
 		if (SUCCEEDED(result))
@@ -55,7 +52,7 @@ namespace D3dDdi
 	{
 		if (data.SubResourceIndex >= m_subResources.size())
 		{
-			return m_deviceFuncs.pfnUnlock(m_device, &data);
+			return m_device.getOrigVtable().pfnUnlock(m_device.getHandle(), &data);
 		}
 
 		m_subResources[data.SubResourceIndex].isLocked = false;
@@ -89,7 +86,7 @@ namespace D3dDdi
 			D3DDDIARG_UNLOCK data = {};
 			data.hResource = m_resource;
 			data.SubResourceIndex = subResourceIndex;
-			m_deviceFuncs.pfnUnlock(m_device, &data);
+			m_device.getOrigVtable().pfnUnlock(m_device.getHandle(), &data);
 
 			subResource.surfacePtr = nullptr;
 			subResource.pitch = 0;

DDrawCompat/D3dDdi/RenderTargetResource.h

@@ -8,11 +8,12 @@
 
 namespace D3dDdi
 {
+	class Device;
+
 	class RenderTargetResource
 	{
 	public:
-		RenderTargetResource(const D3DDDI_DEVICEFUNCS& deviceFuncs,
-			HANDLE device, HANDLE resource, D3DDDIFORMAT format, UINT surfaceCount);
+		RenderTargetResource(Device& device, HANDLE resource, D3DDDIFORMAT format, UINT surfaceCount);
 
 		HRESULT lock(D3DDDIARG_LOCK& data);
 		HRESULT unlock(const D3DDDIARG_UNLOCK& data);
@@ -34,8 +35,7 @@ namespace D3dDdi
 
 		void prepareSubResourceForRendering(UINT subResourceIndex);
 
-		const D3DDDI_DEVICEFUNCS& m_deviceFuncs;
-		HANDLE m_device;
+		Device& m_device;
 		HANDLE m_resource;
 		UINT m_bytesPerPixel;
 		std::vector<SubResource> m_subResources;

DDrawCompat/DDrawCompat.vcxproj

@@ -243,6 +243,7 @@
     <ClInclude Include="Common\ScopedCriticalSection.h" />
     <ClInclude Include="Common\Time.h" />
     <ClInclude Include="Config\Config.h" />
+    <ClInclude Include="D3dDdi\Adapter.h" />
     <ClInclude Include="D3dDdi\AdapterCallbacks.h" />
     <ClInclude Include="D3dDdi\AdapterFuncs.h" />
     <ClInclude Include="D3dDdi\D3dDdiVtable.h" />
@@ -320,6 +321,7 @@
     <ClCompile Include="Common\Log.cpp" />
     <ClCompile Include="Common\Hook.cpp" />
     <ClCompile Include="Common\Time.cpp" />
+    <ClCompile Include="D3dDdi\Adapter.cpp" />
     <ClCompile Include="D3dDdi\AdapterCallbacks.cpp" />
     <ClCompile Include="D3dDdi\AdapterFuncs.cpp" />
     <ClCompile Include="D3dDdi\Device.cpp" />

DDrawCompat/DDrawCompat.vcxproj.filters

@@ -345,6 +345,9 @@
     <ClInclude Include="Common\FuncNameVisitor.h">
       <Filter>Header Files\Common</Filter>
     </ClInclude>
+    <ClInclude Include="D3dDdi\Adapter.h">
+      <Filter>Header Files\D3dDdi</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Gdi\Gdi.cpp">
@@ -524,6 +527,9 @@
     <ClCompile Include="D3dDdi\ScopedCriticalSection.cpp">
       <Filter>Source Files\D3dDdi</Filter>
     </ClCompile>
+    <ClCompile Include="D3dDdi\Adapter.cpp">
+      <Filter>Source Files\D3dDdi</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="Dll\DDrawCompat.def">