static HRESULT __stdcall myReset(IDirect3DDevice9 * idd, D3DPRESENT_PARAMETERS *param) {
ods("D3D9: Chaining Reset");
DevState *ds = devMap[idd];
if (ds) {
DWORD dwOldThread = ds->dwMyThread;
if (dwOldThread)
ods("myReset from other thread");
ds->dwMyThread = GetCurrentThreadId();
ds->releaseAll();
ds->dwMyThread = dwOldThread;
resetAdditions();
}
ResetType oReset = (ResetType) hhReset.call;
hhReset.restore();
HRESULT hr=oReset(idd, param);
hhReset.inject();
if (ds)
ds->createCleanState();
return hr;
}
static ULONG __stdcall myRelease(ID3D10Device *pDevice) {
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
ReleaseType oRelease = (ReleaseType) hhRelease.call;
hhRelease.restore();
ULONG res = oRelease(pDevice);
hhRelease.inject();
Mutex m;
DeviceMap::iterator it = devices.find(pDevice);
if (it != devices.end()) {
D10State *ds = it->second;
// If we are receiving a lot of subsequent releases lets eagerly drop
// our state object. If the device presents something again a state
// object is created again just fine anyway.
if (res < ds->lHighMark / 2) {
ods("D3D10: Deleting resources %u < 0.5 * %u", res, ds->lHighMark);
devices.erase(it);
chains.erase(ds->pSwapChain);
delete ds;
ods("D3D10: Deleted");
ds = NULL;
}
}
return res;
}
static HRESULT __stdcall myResetEx(IDirect3DDevice9Ex *idd, D3DPRESENT_PARAMETERS *param, D3DDISPLAYMODEEX *param2) {
ods("D3D9: Chaining ResetEx");
DevMapType::iterator it = devMap.find(idd);
DevState *ds = it != devMap.end() ? it->second : NULL;
if (ds) {
if (ds->dwMyThread) {
ods("D3D9: myResetEx from other thread");
}
Stash<DWORD> stashThread(&(ds->dwMyThread), GetCurrentThreadId());
ds->releaseAll();
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
ResetExType oResetEx = (ResetExType) hhResetEx.call;
hhResetEx.restore();
HRESULT hr = oResetEx(idd, param, param2);
hhResetEx.inject();
if (ds)
ds->createCleanState();
return hr;
}
static ULONG __stdcall myWin8AddRef(IDirect3DDevice9 *idd) {
Mutex m;
DevMapType::iterator it = devMap.find(idd);
DevState *ds = it != devMap.end() ? it->second : NULL;
if (ds && ds->dwMyThread == GetCurrentThreadId()) {
// AddRef is called very often. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: Using own Refcount implementation for call to AddRef (Win8).");
#endif
ds->myRefCount++;
return ds->refCount;
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
AddRefType oAddRef = (AddRefType) hhAddRef.call;
hhAddRef.restore();
ULONG res = oAddRef(idd);
hhAddRef.inject();
if (ds)
ds->refCount = res;
// AddRef is called very often. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: Chained AddRef (Win8) with result %d", res);
#endif
return res;
}
static HRESULT __stdcall myReset(IDirect3DDevice9 * idd, D3DPRESENT_PARAMETERS *param) {
ods("D3D9: Chaining Reset");
DevState *ds = devMap[idd];
if (ds) {
DWORD dwOldThread = ds->dwMyThread;
if (dwOldThread)
ods("D3D9: myReset from other thread");
ds->dwMyThread = GetCurrentThreadId();
ds->releaseAll();
ds->dwMyThread = dwOldThread;
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
ResetType oReset = (ResetType) hhReset.call;
hhReset.restore();
HRESULT hr = oReset(idd, param);
hhReset.inject();
if (ds)
ds->createCleanState();
return hr;
}
static ULONG __stdcall myWin8AddRef(IDirect3DDevice9 *idd) {
Mutex m;
ods("D3D9: Chaining AddRef (Win8)");
DevState *ds = devMap[idd];
if (ds && ds->dwMyThread == GetCurrentThreadId()) {
ds->myRefCount++;
return ds->refCount;
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
AddRefType oAddRef = (AddRefType) hhAddRef.call;
hhAddRef.restore();
ULONG res = oAddRef(idd);
hhAddRef.inject();
if (ds)
ds->refCount = res;
ods("D3D9: Chained AddRef (Win8) with result %d", res);
return res;
}
static ULONG __stdcall myRelease(IDirect3DDevice9 *idd) {
Mutex m;
DevMapType::iterator it = devMap.find(idd);
DevState *ds = it != devMap.end() ? it->second : NULL;
if (ds) {
// Release is called very often. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: Using own Refcount implementation for call to Release.");
#endif
if (ds->dwMyThread == GetCurrentThreadId()) {
ds->myRefCount--;
return ds->initRefCount + ds->refCount;
} else {
ds->refCount--;
}
if (ds->refCount <= 1) {
ds->disconnect();
}
if (ds->refCount >= 0) {
return ds->initRefCount + ds->refCount;
}
ods("D3D9: Final release is following. MyRefs = %d, Tot = %d", ds->myRefCount, ds->refCount);
if (ds->dwMyThread != 0) {
ods("D3D9: finalRelease from other thread");
}
// Codeblock for stashing threadid
{
Stash<DWORD> stashThread(&(ds->dwMyThread), GetCurrentThreadId());
ds->releaseAll();
}
ods("D3D9: Final release of %p. MyRefs = %d Tot = %d", idd, ds->myRefCount, ds->refCount);
devMap.erase(it);
delete ds;
ds = NULL;
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
ReleaseType oRelease = (ReleaseType) hhRelease.call;
hhRelease.restore();
ULONG res = oRelease(idd);
hhRelease.inject();
// Release is called very often. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: Chained Release with result %d", res);
#endif
return res;
}
static HRESULT __stdcall myCreateDeviceEx(IDirect3D9Ex * id3d, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS *pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode, IDirect3DDevice9Ex** ppReturnedDeviceInterface) {
Mutex m;
ods("D3D9: Chaining CreateDeviceEx");
// BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
CreateDeviceExType oCreateDeviceEx = (CreateDeviceExType) hhCreateDeviceEx.call;
hhCreateDeviceEx.restore();
HRESULT hr = oCreateDeviceEx(id3d, Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, pFullscreenDisplayMode, ppReturnedDeviceInterface);
hhCreateDeviceEx.inject();
if (FAILED(hr))
return hr;
IDirect3DDevice9Ex *idd = *ppReturnedDeviceInterface;
DevState *ds = new DevState;
ds->dev = idd;
idd->AddRef();
ds->initRefCount = idd->Release();
devMap[idd] = ds;
// The offsets are dependent on the declaration order of the struct.
// See IDirect3DDevice9 (2nd, 3rd, 17th, 18th functions)
const unsigned int offsetAddref = 1;
const unsigned int offsetRelease = 2;
const unsigned int offsetReset = 16;
const unsigned int offsetPresent = 17;
if (bIsWin8) {
hhAddRef.setupInterface(idd, offsetAddref, reinterpret_cast<voidFunc>(myWin8AddRef));
hhRelease.setupInterface(idd, offsetRelease, reinterpret_cast<voidFunc>(myWin8Release));
} else {
hhAddRef.setupInterface(idd, offsetAddref, reinterpret_cast<voidFunc>(myAddRef));
hhRelease.setupInterface(idd, offsetRelease, reinterpret_cast<voidFunc>(myRelease));
}
hhReset.setupInterface(idd, offsetReset, reinterpret_cast<voidFunc>(myReset));
hhPresent.setupInterface(idd, offsetPresent, reinterpret_cast<voidFunc>(myPresent));
IDirect3DSwapChain9 *pSwap = NULL;
idd->GetSwapChain(0, &pSwap);
if (pSwap) {
// The offset is dependent on the declaration order of the struct.
// See IDirect3DSwapChain9 (Present is the fourth function)
const unsigned int offsetPresent = 3;
hhSwapPresent.setupInterface(pSwap, offsetPresent, reinterpret_cast<voidFunc>(mySwapPresent));
pSwap->Release();
} else {
ods("D3D9: Failed to get swapchain for DevEx");
}
ds->createCleanState();
return hr;
}
static HRESULT __stdcall myPresent(IDirect3DDevice9 * idd, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) {
ods("D3D9: Device Present");
myAdditions(idd);
doPresent(idd);
PresentType oPresent = (PresentType) hhPresent.call;
hhPresent.restore();
HRESULT hr = oPresent(idd,pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion);
hhPresent.inject();
return hr;
}
static HRESULT __stdcall myPresent(IDirect3DDevice9 * idd, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) {
ods("D3D9: Device Present");
doPresent(idd);
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
PresentType oPresent = (PresentType) hhPresent.call;
hhPresent.restore();
HRESULT hr = oPresent(idd,pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion);
hhPresent.inject();
return hr;
}
static void dllmainProcDetach() {
hhLoad.restore(true);
hhLoad.reset();
hhLoadW.restore(true);
hhLoadW.reset();
if (sd)
UnmapViewOfFile(sd);
if (hMapObject)
CloseHandle(hMapObject);
if (hHookMutex)
CloseHandle(hHookMutex);
}
static ULONG __stdcall myAddRef(ID3D10Device *pDevice) {
AddRefType oAddRef = (AddRefType) hhAddRef.call;
hhAddRef.restore();
LONG res = oAddRef(pDevice);
hhAddRef.inject();
Mutex m;
D10State *ds = devices[pDevice];
if (ds)
ds->lHighMark = res;
return res;
}
static HRESULT __stdcall myPresentEx(IDirect3DDevice9Ex *idd, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion, DWORD dwFlags) {
// Present is called for each frame. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: Device Present Ex");
#endif
doPresent(idd);
PresentExType oPresentEx = (PresentExType) hhPresentEx.call;
hhPresentEx.restore();
HRESULT hr = oPresentEx(idd, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
hhPresentEx.inject();
return hr;
}
static ULONG __stdcall myRelease(IDirect3DDevice9 *idd) {
Mutex m;
ods("D3D9: Chaining Release");
DevState *ds = devMap[idd];
if (ds) {
if (ds->dwMyThread == GetCurrentThreadId()) {
ds->myRefCount--;
return ds->refCount + ds->initRefCount;
} else {
ds->refCount--;
}
if (ds->refCount <= 1)
ds->disconnect();
if (ds->refCount >= 0)
return ds->refCount + ds->initRefCount;
ods("D3D9: Final release is following. MyRefs = %d, Tot = %d", ds->myRefCount, ds->refCount);
DWORD dwOldThread = ds->dwMyThread;
if (dwOldThread)
ods("D3D9: finalRelease from other thread");
ds->dwMyThread = GetCurrentThreadId();
ds->releaseAll();
ds->dwMyThread = dwOldThread;
ods("D3D9: Final release. MyRefs = %d Tot = %d", ds->myRefCount, ds->refCount);
devMap.erase(idd);
delete ds;
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
ReleaseType oRelease = (ReleaseType) hhRelease.call;
hhRelease.restore();
ULONG res = oRelease(idd);
hhRelease.inject();
ods("D3D9: Chained Release with result %d", res);
return res;
}
static ULONG __stdcall myAddRef(ID3D10Device *pDevice) {
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
AddRefType oAddRef = (AddRefType) hhAddRef.call;
hhAddRef.restore();
ULONG res = oAddRef(pDevice);
hhAddRef.inject();
Mutex m;
DeviceMap::iterator it = devices.find(pDevice);
if (it != devices.end()) {
it->second->lHighMark = res;
}
return res;
}
static HRESULT __stdcall myResize(IDXGISwapChain *pSwapChain, UINT BufferCount, UINT Width, UINT Height, DXGI_FORMAT NewFormat, UINT SwapChainFlags) {
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("DXGI: Call to Resize. Forwarding to D3D10 and D3D11 custom implementations before calling original logic ...");
#endif
resizeD3D10(pSwapChain);
resizeD3D11(pSwapChain);
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
ResizeBuffersType oResize = (ResizeBuffersType) hhResize.call;
hhResize.restore();
HRESULT hr = oResize(pSwapChain, BufferCount, Width, Height, NewFormat, SwapChainFlags);
hhResize.inject();
return hr;
}
static HRESULT __stdcall myResize(IDXGISwapChain *pSwapChain, UINT BufferCount, UINT Width, UINT Height, DXGI_FORMAT NewFormat, UINT SwapChainFlags) {
HRESULT hr;
D10State *ds = chains[pSwapChain];
if (ds) {
devices.erase(ds->pDevice);
chains.erase(pSwapChain);
delete ds;
}
ResizeBuffersType oResize = (ResizeBuffersType) hhResize.call;
hhResize.restore();
hr = oResize(pSwapChain, BufferCount, Width, Height, NewFormat, SwapChainFlags);
hhResize.inject();
return hr;
}
static HMODULE WINAPI MyLoadLibrary(const char *lpFileName) {
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
LoadLibraryAType oLoadLibrary = (LoadLibraryAType) hhLoad.call;
hhLoad.restore();
HMODULE h = oLoadLibrary(lpFileName);
hhLoad.inject();
ods("Lib: Library %s loaded to %p", lpFileName, h);
if (! bBlackListed) {
checkHooks();
}
return h;
}
static HRESULT __stdcall myPresent(IDirect3DDevice9 *idd, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride,CONST RGNDATA *pDirtyRegion) {
// Present is called for each frame. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: Device Present");
#endif
doPresent(idd);
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
PresentType oPresent = (PresentType) hhPresent.call;
hhPresent.restore();
HRESULT hr = oPresent(idd, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
hhPresent.inject();
return hr;
}
static void dllmainProcAttach(char *procname) {
Mutex::init();
char *p = strrchr(procname, '\\');
if (!p) {
// No blacklisting if the file has no path
} else if (GetProcAddress(NULL, "mumbleSelfDetection") != NULL) {
ods("Lib: Attached to overlay helper or Mumble process. Blacklisted - no overlay injection.");
bBlackListed = TRUE;
bMumble = TRUE;
} else {
if (dllmainProcAttachCheckProcessIsBlacklisted(procname, p)) {
ods("Lib: Process %s is blacklisted - no overlay injection.", procname);
return;
}
}
OSVERSIONINFOEX ovi;
memset(&ovi, 0, sizeof(ovi));
ovi.dwOSVersionInfoSize = sizeof(ovi);
GetVersionEx(reinterpret_cast<OSVERSIONINFO *>(&ovi));
bIsWin8 = (ovi.dwMajorVersion >= 7) || ((ovi.dwMajorVersion == 6) && (ovi.dwBuildNumber >= 9200));
ods("Lib: bIsWin8: %i", bIsWin8);
hHookMutex = CreateMutex(NULL, false, "MumbleHookMutex");
if (hHookMutex == NULL) {
ods("Lib: CreateMutex failed");
return;
}
if(!createSharedDataMap())
return;
if (! bMumble) {
// Hook our own LoadLibrary functions so we notice when a new library (like the d3d ones) is loaded.
hhLoad.setup(reinterpret_cast<voidFunc>(LoadLibraryA), reinterpret_cast<voidFunc>(MyLoadLibrary));
hhLoadW.setup(reinterpret_cast<voidFunc>(LoadLibraryW), reinterpret_cast<voidFunc>(MyLoadLibraryW));
checkHooks(true);
ods("Lib: Injected into %s", procname);
}
}
static void HookCreateEx(IDirect3D9Ex *pD3D) {
ods("D3D9Ex: Injecting CreateDevice / CreateDeviceEx");
// Best effort hooking for the non-ex create method. If it was set up
// previously this setup call is safely ignored by the hook.
HookCreate(pD3D);
hhCreateDeviceEx.setupInterface(pD3D, VTABLE_OFFSET_ID3D_CREATEDEVICE_EX, reinterpret_cast<voidFunc>(myCreateDeviceEx));
}
static ULONG __stdcall myAddRef(IDirect3DDevice9 *idd) {
Mutex m;
DevState *ds = devMap[idd];
if (ds) {
if (ds->dwMyThread == GetCurrentThreadId()) {
ds->myRefCount++;
} else
ds->refCount++;
return ds->refCount + ds->initRefCount;
}
AddRefType oAddRef = (AddRefType) hhAddRef.call;
hhAddRef.restore();
LONG res = oAddRef(idd);
hhAddRef.inject();
ods("D3D9: Chaining AddRef: %d", res);
return res;
}
static HRESULT __stdcall mySwapPresent(IDirect3DSwapChain9 * ids, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion, DWORD dwFlags) {
ods("D3D9: SwapChain Present");
IDirect3DDevice9 *idd = NULL;
ids->GetDevice(&idd);
if (idd) {
doPresent(idd);
idd->Release();
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
SwapPresentType oSwapPresent = (SwapPresentType) hhSwapPresent.call;
hhSwapPresent.restore();
HRESULT hr = oSwapPresent(ids, pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion,dwFlags);
hhSwapPresent.inject();
return hr;
}
static ULONG __stdcall myRelease(IDirect3DDevice9 *idd) {
Mutex m;
DevState *ds = devMap[idd];
if (ds) {
if (ds->dwMyThread == GetCurrentThreadId()) {
ds->myRefCount--;
return ds->refCount + ds->initRefCount;
} else {
ds->refCount--;
}
if (ds->refCount <= 1)
ds->disconnect();
if (ds->refCount >= 0)
return ds->refCount + ds->initRefCount;
ods("D3D9: Final release. MyRefs = %d, Tot = %d", ds->myRefCount, ds->refCount);
DWORD dwOldThread = ds->dwMyThread;
if (dwOldThread)
ods("finalRelease from other thread");
ds->dwMyThread = GetCurrentThreadId();
ds->releaseAll();
ds->dwMyThread = dwOldThread;
resetAdditions();
ods("D3D9: Final release, MyRefs = %d Tot = %d", ds->myRefCount, ds->refCount);
devMap.erase(idd);
delete ds;
}
ReleaseType oRelease = (ReleaseType) hhRelease.call;
hhRelease.restore();
LONG res = oRelease(idd);
hhRelease.inject();
ods("D3D9: Chaining Release: %d", res);
return res;
}
static HRESULT __stdcall myCreateDeviceEx(IDirect3D9Ex * id3d, UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS *pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode, IDirect3DDevice9Ex** ppReturnedDeviceInterface) {
Mutex m;
ods("D3D9: Chaining CreateDeviceEx");
// BehaviorFlags &= ~D3DCREATE_PUREDEVICE;
CreateDeviceExType oCreateDeviceEx = (CreateDeviceExType) hhCreateDeviceEx.call;
hhCreateDeviceEx.restore();
HRESULT hr=oCreateDeviceEx(id3d, Adapter,DeviceType,hFocusWindow,BehaviorFlags,pPresentationParameters,pFullscreenDisplayMode,ppReturnedDeviceInterface);
hhCreateDeviceEx.inject();
if (FAILED(hr))
return hr;
IDirect3DDevice9Ex *idd = *ppReturnedDeviceInterface;
DevState *ds = new DevState;
ds->dev = idd;
idd->AddRef();
ds->initRefCount = idd->Release();
devMap[idd] = ds;
if (bIsWin8) {
hhAddRef.setupInterface(idd, 1, reinterpret_cast<voidFunc>(myWin8AddRef));
hhRelease.setupInterface(idd, 2, reinterpret_cast<voidFunc>(myWin8Release));
} else {
hhAddRef.setupInterface(idd, 1, reinterpret_cast<voidFunc>(myAddRef));
hhRelease.setupInterface(idd, 2, reinterpret_cast<voidFunc>(myRelease));
}
hhReset.setupInterface(idd, 16, reinterpret_cast<voidFunc>(myReset));
hhPresent.setupInterface(idd, 17, reinterpret_cast<voidFunc>(myPresent));
IDirect3DSwapChain9 *pSwap = NULL;
idd->GetSwapChain(0, &pSwap);
if (pSwap) {
hhSwapPresent.setupInterface(pSwap, 3, reinterpret_cast<voidFunc>(mySwapPresent));
pSwap->Release();
} else {
ods("D3D9: Failed to get swapchain for DevEx");
}
ds->createCleanState();
return hr;
}
static ULONG __stdcall myWin8Release(IDirect3DDevice9 *idd) {
Mutex m;
DevState *ds = devMap[idd];
if (ds) {
if (ds->dwMyThread == GetCurrentThreadId()) {
ds->myRefCount--;
return ds->refCount;
}
if (ds->refCount == 1) {
ds->disconnect();
ods("D3D9: Final release. MyRefs = %d, Tot = %d", ds->myRefCount, ds->refCount);
DWORD dwOldThread = ds->dwMyThread;
if (dwOldThread)
ods("finalRelease from other thread");
ds->dwMyThread = GetCurrentThreadId();
ds->releaseAll();
ds->dwMyThread = dwOldThread;
CustomHUD::Reset();
ods("D3D9: Final release, MyRefs = %d Tot = %d", ds->myRefCount, ds->refCount);
devMap.erase(idd);
delete ds;
ds = NULL;
}
}
ReleaseType oRelease = (ReleaseType) hhRelease.call;
hhRelease.restore();
LONG res = oRelease(idd);
if (ds)
ds->refCount = res;
hhRelease.inject();
ods("D3D9: Chaining Release (Win8): %d", res);
return res;
}
static HRESULT __stdcall myPresent(IDXGISwapChain *pSwapChain, UINT SyncInterval, UINT Flags) {
// Present is called for each frame. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("DXGI: Call to Present; Drawing and then chaining the call to the original logic");
#endif
// From this D3D-version-independent point, call the present logic for both
// D3D 10 and 11. Those that apply will be executed adequately, those that
// do not will (silently) fail.
presentD3D10(pSwapChain);
presentD3D11(pSwapChain);
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
PresentType oPresent = (PresentType) hhPresent.call;
hhPresent.restore();
HRESULT hr = oPresent(pSwapChain, SyncInterval, Flags);
hhPresent.inject();
return hr;
}
static ULONG __stdcall myRelease(ID3D10Device *pDevice) {
ReleaseType oRelease = (ReleaseType) hhRelease.call;
hhRelease.restore();
LONG res = oRelease(pDevice);
hhRelease.inject();
Mutex m;
D10State *ds = devices[pDevice];
if (ds)
if (res < (ds->lHighMark / 2)) {
ods("D3D10: Deleting resources %d < .5 %d", res, ds->lHighMark);
devices.erase(ds->pDevice);
chains.erase(ds->pSwapChain);
delete ds;
ods("D3D10: Deleted");
ds = NULL;
}
return res;
}
void freeD3D9Hook(HMODULE hModule) {
HMODULE hD3D = GetModuleHandle("D3D9.DLL");
if (bHooked && !hD3D) {
ods("D3D9: Freeing hooks for module %p", hModule);
hhCreateDevice.reset();
hhCreateDeviceEx.reset();
hhReset.reset();
hhResetEx.reset();
hhAddRef.reset();
hhRelease.reset();
hhPresent.reset();
hhPresentEx.reset();
hhSwapPresent.reset();
bHooked = false;
}
}
static HRESULT __stdcall mySwapPresent(IDirect3DSwapChain9 *ids, CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion, DWORD dwFlags) {
// Present is called for each frame. Thus, we do not want to always log here.
#ifdef EXTENDED_OVERLAY_DEBUGOUTPUT
ods("D3D9: SwapChain Present");
#endif
IDirect3DDevice9 *idd = NULL;
ids->GetDevice(&idd);
if (idd) {
doPresent(idd);
idd->Release();
}
//TODO: Move logic to HardHook.
// Call base without active hook in case of no trampoline.
SwapPresentType oSwapPresent = (SwapPresentType) hhSwapPresent.call;
hhSwapPresent.restore();
HRESULT hr = oSwapPresent(ids, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags);
hhSwapPresent.inject();
return hr;
}
