From 881dfccf8956976dab8f242e25c26e86cbd745ff Mon Sep 17 00:00:00 2001 From: =?utf8?q?Jos=C3=A9=20Fonseca?= Date: Sat, 5 Jul 2008 10:58:50 +0900 Subject: [PATCH] Initial import of Michael Koch's "basic proxy-dll" source. --- .gitignore | 5 + README | 12 + SConstruct | 90 ++++++ d3d8/SConscript | 11 + d3d8/d3d8.def | 4 + d3d8/dllmain.cpp | 90 ++++++ d3d8/idirect3d8.cpp | 102 ++++++ d3d8/idirect3d8.hpp | 34 ++ d3d8/idirect3d_device8.cpp | 421 +++++++++++++++++++++++++ d3d8/idirect3d_device8.hpp | 118 +++++++ d3d8/stdafx.h | 12 + d3d9/SConscript | 12 + d3d9/d3d9.def | 4 + d3d9/dllmain.cpp | 101 ++++++ d3d9/dllmain.hpp | 10 + d3d9/idirect3d9.cpp | 114 +++++++ d3d9/idirect3d9.hpp | 31 ++ d3d9/idirect3d_device9.cpp | 572 ++++++++++++++++++++++++++++++++++ d3d9/idirect3d_device9.hpp | 135 ++++++++ d3d9/idirect3d_swapchain9.cpp | 96 ++++++ d3d9/idirect3d_swapchain9.hpp | 27 ++ d3d9/stdafx.h | 12 + 22 files changed, 2013 insertions(+) create mode 100644 .gitignore create mode 100644 README create mode 100644 SConstruct create mode 100644 d3d8/SConscript create mode 100644 d3d8/d3d8.def create mode 100644 d3d8/dllmain.cpp create mode 100644 d3d8/idirect3d8.cpp create mode 100644 d3d8/idirect3d8.hpp create mode 100644 d3d8/idirect3d_device8.cpp create mode 100644 d3d8/idirect3d_device8.hpp create mode 100644 d3d8/stdafx.h create mode 100644 d3d9/SConscript create mode 100644 d3d9/d3d9.def create mode 100644 d3d9/dllmain.cpp create mode 100644 d3d9/dllmain.hpp create mode 100644 d3d9/idirect3d9.cpp create mode 100644 d3d9/idirect3d9.hpp create mode 100644 d3d9/idirect3d_device9.cpp create mode 100644 d3d9/idirect3d_device9.hpp create mode 100644 d3d9/idirect3d_swapchain9.cpp create mode 100644 d3d9/idirect3d_swapchain9.hpp create mode 100644 d3d9/stdafx.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b79cb08 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +*.obj +*.dll +*.lib +*.exp +.scons* diff --git a/README b/README new file mode 100644 index 0000000..cbb04e4 --- /dev/null +++ b/README @@ -0,0 +1,12 @@ +Wrapper DLLs to trace D3D8 and D3D9 APIs calls. + +Base on the idea and code (public domain) from Michael Koch. + +See also: +- http://www.mikoweb.eu/index.php?node=21 +- http://www.codeguru.com/cpp/g-m/directx/directx8/article.php/c11453/ +- http://doc.51windows.net/Directx9_SDK/?url=/directx9_sdk/graphics/programmingguide/TutorialsAndSamplesAndToolsAndTips/Tools/D3DSpy.htm + + +-- +Jose Fonseca \ No newline at end of file diff --git a/SConstruct b/SConstruct new file mode 100644 index 0000000..aeeb3f6 --- /dev/null +++ b/SConstruct @@ -0,0 +1,90 @@ +####################################################################### +# Top-level SConstruct +# +# For example, invoke scons as +# +# scons debug=1 +# +# to set configuration variables. Or you can write those options to a file +# named config.py: +# +# # config.py +# debug=1 +# dxsdk='C:\\DXSDK' +# +# Invoke +# +# scons -h +# +# to get the full list of options. See scons manpage for more info. +# + +import os +import os.path +import sys + +opts = Options('config.py') +opts.Add(BoolOption('debug', 'build debug version', 'no')) +opts.Add(PathOption('dxsdk', 'DirectX SDK installation dir', os.environ.get('DXSDK_DIR', 'C:\\DXSDK'))) + +env = Environment( + options = opts, + ENV = os.environ) +Help(opts.GenerateHelpText(env)) + +env.Append(CPPDEFINES = [ + 'WIN32', + '_WINDOWS', + '_UNICODE', + 'UNICODE', + '_CRT_SECURE_NO_DEPRECATE', + '_CRT_NON_CONFORMING_SWPRINTFS', +]) + +if env['debug']: + env.Append(CPPDEFINES = ['_DEBUG']) +else: + env.Append(CPPDEFINES = ['NDEBUG']) +#env['PDB'] = '${TARGET.base}.pdb' + +cflags = [ + '/W3', # warning level +] +if env['debug']: + cflags += [ + '/Od', # disable optimizations + '/Oi', # enable intrinsic functions + '/Oy-', # disable frame pointer omission + ] +else: + cflags += [ + '/Ox', # maximum optimizations + '/Oi', # enable intrinsic functions + '/Os', # favor code space + ] +env.Append(CFLAGS = cflags) +env.Append(CXXFLAGS = cflags) + +env.Prepend(LIBS = [ + 'kernel32', + 'user32', + 'gdi32', + 'winspool', + 'comdlg32', + 'advapi32', + 'shell32', + 'ole32', + 'oleaut32', + 'uuid', + 'odbc32', + 'odbccp32', +]) + +env.Append(CPPPATH = [ + os.path.join(env['dxsdk'], 'Include'), +]) + +Export('env') + +SConscript('d3d8/SConscript') +SConscript('d3d9/SConscript') diff --git a/d3d8/SConscript b/d3d8/SConscript new file mode 100644 index 0000000..b011c37 --- /dev/null +++ b/d3d8/SConscript @@ -0,0 +1,11 @@ +Import('env') + +env.SharedLibrary( + target = 'd3d8.dll', + source = [ + 'd3d8.def', + 'dllmain.cpp', + 'idirect3d8.cpp', + 'idirect3d_device8.cpp', + ] +) diff --git a/d3d8/d3d8.def b/d3d8/d3d8.def new file mode 100644 index 0000000..5134cb8 --- /dev/null +++ b/d3d8/d3d8.def @@ -0,0 +1,4 @@ +LIBRARY "d3d8" + +EXPORTS + Direct3DCreate8 @1 diff --git a/d3d8/dllmain.cpp b/d3d8/dllmain.cpp new file mode 100644 index 0000000..d1c2efb --- /dev/null +++ b/d3d8/dllmain.cpp @@ -0,0 +1,90 @@ +// proxydll.cpp +#include "stdafx.h" + +// global variables +#pragma data_seg (".d3d8_shared") +static HINSTANCE gl_hOriginalDll; +static HINSTANCE gl_hThisInstance; +#pragma data_seg () + +static void InitInstance(HANDLE hModule) { + OutputDebugString(_T("PROXYDLL: InitInstance called.\r\n")); + + // Initialisation + gl_hOriginalDll = NULL; + gl_hThisInstance = NULL; + + // Storing Instance handle into global var + gl_hThisInstance = (HINSTANCE) hModule; +} + +static void LoadOriginalDll(void) { + TCHAR buffer[MAX_PATH]; + + // Getting path to system dir and to d3d8.dll + ::GetSystemDirectory(buffer, MAX_PATH); + + // Append dll name + _tcscat(buffer, _T("\\d3d8.dll")); + + // try to load the system's d3d8.dll, if pointer empty + if (!gl_hOriginalDll) + gl_hOriginalDll = ::LoadLibrary(buffer); + + // Debug + if (!gl_hOriginalDll) { + OutputDebugString(_T("PROXYDLL: Original d3d8.dll not loaded ERROR ****\r\n")); + ::ExitProcess(0); // exit the hard way + } +} + +static void ExitInstance() { + OutputDebugString(_T("PROXYDLL: ExitInstance called.\r\n")); + + // Release the system's d3d8.dll + if (gl_hOriginalDll) { + ::FreeLibrary(gl_hOriginalDll); + gl_hOriginalDll = NULL; + } +} + +BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) +{ + // to avoid compiler lvl4 warnings + LPVOID lpDummy = lpReserved; + lpDummy = NULL; + + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: InitInstance(hModule); break; + case DLL_PROCESS_DETACH: ExitInstance(); break; + + case DLL_THREAD_ATTACH: break; + case DLL_THREAD_DETACH: break; + } + return TRUE; +} + +// Exported function (faking d3d8.dll's one-and-only export) +IDirect3D8* WINAPI Direct3DCreate8(UINT SDKVersion) +{ + if (!gl_hOriginalDll) LoadOriginalDll(); // looking for the "right d3d8.dll" + + // Hooking IDirect3D Object from Original Library + typedef IDirect3D8 *(WINAPI* D3D8_Type)(UINT SDKVersion); + D3D8_Type D3DCreate8_fn = (D3D8_Type) GetProcAddress( gl_hOriginalDll, "Direct3DCreate8"); + + // Debug + if (!D3DCreate8_fn) + { + OutputDebugString(_T("PROXYDLL: Pointer to original D3DCreate8 function not received ERROR ****\r\n")); + ::ExitProcess(0); // exit the hard way + } + + // Request pointer from Original Dll. + IDirect3D8 *pIDirect3D8_orig = D3DCreate8_fn(SDKVersion); + + // Create my IDirect3D8 object and store pointer to original object there. + // note: the object will delete itself once Ref count is zero (similar to COM objects) + return new TraceDirect3D8(pIDirect3D8_orig); +} diff --git a/d3d8/idirect3d8.cpp b/d3d8/idirect3d8.cpp new file mode 100644 index 0000000..ceaef09 --- /dev/null +++ b/d3d8/idirect3d8.cpp @@ -0,0 +1,102 @@ +// TraceDirect3D8.cpp +#include "stdafx.h" + +TraceDirect3D8::TraceDirect3D8(IDirect3D8 *pOriginal) { + m_pIDirect3D8 = pOriginal; // store the pointer to original object +} + +TraceDirect3D8::~TraceDirect3D8() { + +} + +HRESULT __stdcall TraceDirect3D8::QueryInterface(REFIID riid, void** ppvObj) { + *ppvObj = NULL; + + // call this to increase AddRef at original object + // and to check if such an interface is there + + HRESULT hRes = m_pIDirect3D8->QueryInterface(riid, ppvObj); + + if (hRes == NOERROR) // if OK, send our "fake" address + { + *ppvObj = this; + } + + return hRes; +} + +ULONG __stdcall TraceDirect3D8::AddRef() { + return (m_pIDirect3D8->AddRef()); +} + +ULONG __stdcall TraceDirect3D8::Release() { + // call original routine + ULONG count = m_pIDirect3D8->Release(); + + // in case no further Ref is there, the Original Object has deleted itself + // so do we here + if (count == 0) { + delete (this); + } + + return (count); +} + +HRESULT __stdcall TraceDirect3D8::RegisterSoftwareDevice(void* pInitializeFunction) { + return (m_pIDirect3D8->RegisterSoftwareDevice(pInitializeFunction)); +} + +UINT __stdcall TraceDirect3D8::GetAdapterCount() { + return (m_pIDirect3D8->GetAdapterCount()); +} + +HRESULT __stdcall TraceDirect3D8::GetAdapterIdentifier(UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER8* pIdentifier) { + return (m_pIDirect3D8->GetAdapterIdentifier(Adapter, Flags, pIdentifier)); +} + +UINT __stdcall TraceDirect3D8::GetAdapterModeCount(UINT Adapter) { + return (m_pIDirect3D8->GetAdapterModeCount(Adapter)); +} + +HRESULT __stdcall TraceDirect3D8::EnumAdapterModes(UINT Adapter, UINT Mode, D3DDISPLAYMODE* pMode) { + return (m_pIDirect3D8->EnumAdapterModes(Adapter, Mode, pMode)); +} + +HRESULT __stdcall TraceDirect3D8::GetAdapterDisplayMode(UINT Adapter, D3DDISPLAYMODE* pMode) { + return (m_pIDirect3D8->GetAdapterDisplayMode(Adapter, pMode)); +} + +HRESULT __stdcall TraceDirect3D8::CheckDeviceType(UINT Adapter, D3DDEVTYPE CheckType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL Windowed) { + return (m_pIDirect3D8->CheckDeviceType(Adapter, CheckType, DisplayFormat, BackBufferFormat, Windowed)); +} + +HRESULT __stdcall TraceDirect3D8::CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { + return (m_pIDirect3D8->CheckDeviceFormat(Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat)); +} + +HRESULT __stdcall TraceDirect3D8::CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType) { + return (m_pIDirect3D8->CheckDeviceMultiSampleType(Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType)); +} + +HRESULT __stdcall TraceDirect3D8::CheckDepthStencilMatch(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) { + return (m_pIDirect3D8->CheckDepthStencilMatch(Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat)); +} + +HRESULT __stdcall TraceDirect3D8::GetDeviceCaps(UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS8* pCaps) { + return (m_pIDirect3D8->GetDeviceCaps(Adapter, DeviceType, pCaps)); +} + +HMONITOR __stdcall TraceDirect3D8::GetAdapterMonitor(UINT Adapter) { + return (m_pIDirect3D8->GetAdapterMonitor(Adapter)); +} + +HRESULT __stdcall TraceDirect3D8::CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DDevice8** ppReturnedDeviceInterface) { + // we intercept this call and provide our own "fake" Device Object + HRESULT hres = m_pIDirect3D8->CreateDevice(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface); + + // Create our own Device object and strore it in global pointer + // note: the object will delete itself once Ref count is zero (similar to COM objects) + *ppReturnedDeviceInterface = new TraceDirect3DDevice8(*ppReturnedDeviceInterface); + + return (hres); +} diff --git a/d3d8/idirect3d8.hpp b/d3d8/idirect3d8.hpp new file mode 100644 index 0000000..4c5c2e7 --- /dev/null +++ b/d3d8/idirect3d8.hpp @@ -0,0 +1,34 @@ +// TraceDirect3D8.h +#pragma once + +class TraceDirect3D8 : public IDirect3D8 +{ +public: + + TraceDirect3D8(IDirect3D8 *pOriginal); + virtual ~TraceDirect3D8(); + + // START: The original DX8.1a function definitions + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj); + ULONG __stdcall AddRef(void); + ULONG __stdcall Release(void); + HRESULT __stdcall RegisterSoftwareDevice(void* pInitializeFunction); + UINT __stdcall GetAdapterCount(void); + HRESULT __stdcall GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER8* pIdentifier); + UINT __stdcall GetAdapterModeCount(UINT Adapter); + HRESULT __stdcall EnumAdapterModes(UINT Adapter,UINT Mode,D3DDISPLAYMODE* pMode); + HRESULT __stdcall GetAdapterDisplayMode( UINT Adapter,D3DDISPLAYMODE* pMode); + HRESULT __stdcall CheckDeviceType(UINT Adapter,D3DDEVTYPE CheckType,D3DFORMAT DisplayFormat,D3DFORMAT BackBufferFormat,BOOL Windowed); + HRESULT __stdcall CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat); + HRESULT __stdcall CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType); + HRESULT __stdcall CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat); + HRESULT __stdcall GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS8* pCaps); + HMONITOR __stdcall GetAdapterMonitor(UINT Adapter); + HRESULT __stdcall CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice8** ppReturnedDeviceInterface); + // END: The original DX8,1a functions definitions + +private: + + IDirect3D8 * m_pIDirect3D8; +}; + diff --git a/d3d8/idirect3d_device8.cpp b/d3d8/idirect3d_device8.cpp new file mode 100644 index 0000000..d0d09bb --- /dev/null +++ b/d3d8/idirect3d_device8.cpp @@ -0,0 +1,421 @@ +// TraceDirect3DDevice8.cpp +#include "stdafx.h" + +TraceDirect3DDevice8::TraceDirect3DDevice8(IDirect3DDevice8* pOriginal) { + m_pIDirect3DDevice8 = pOriginal; // store the pointer to original object +} + +TraceDirect3DDevice8::~TraceDirect3DDevice8() { + +} + +HRESULT __stdcall TraceDirect3DDevice8::QueryInterface(REFIID riid, void** ppvObj) { + // check if original dll can provide an interface. then send *our* address + *ppvObj = NULL; + + HRESULT hRes = m_pIDirect3DDevice8->QueryInterface(riid, ppvObj); + + if (hRes == NOERROR) { + *ppvObj = this; + } + + return hRes; +} + +ULONG __stdcall TraceDirect3DDevice8::AddRef(void) { + return (m_pIDirect3DDevice8->AddRef()); +} + +ULONG __stdcall TraceDirect3DDevice8::Release(void) { + // ATTENTION: This is a booby-trap ! Watch out ! + // If we create our own sprites, surfaces, etc. (thus increasing the ref counter + // by external action), we need to delete that objects before calling the original + // Release function + + // release/delete own objects + // ... here if any ... + + // Calling original function now + ULONG count = m_pIDirect3DDevice8->Release(); + + // now, the Original Object has deleted itself, so do we here + delete (this); // destructor will be called automatically + + return (count); +} + +HRESULT __stdcall TraceDirect3DDevice8::TestCooperativeLevel(void) { + return (m_pIDirect3DDevice8->TestCooperativeLevel()); +} + +UINT __stdcall TraceDirect3DDevice8::GetAvailableTextureMem(void) { + return (m_pIDirect3DDevice8->GetAvailableTextureMem()); +} + +HRESULT __stdcall TraceDirect3DDevice8::ResourceManagerDiscardBytes(DWORD Bytes) { + return (m_pIDirect3DDevice8->ResourceManagerDiscardBytes(Bytes)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetDirect3D(IDirect3D8** ppD3D8) { + return (m_pIDirect3DDevice8->GetDirect3D(ppD3D8)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetDeviceCaps(D3DCAPS8* pCaps) { + return (m_pIDirect3DDevice8->GetDeviceCaps(pCaps)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetDisplayMode(D3DDISPLAYMODE* pMode) { + return (m_pIDirect3DDevice8->GetDisplayMode(pMode)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) { + return (m_pIDirect3DDevice8->GetCreationParameters(pParameters)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap) { + return (m_pIDirect3DDevice8->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap)); +} + +void __stdcall TraceDirect3DDevice8::SetCursorPosition(int XScreenSpace, int YScreenSpace, DWORD Flags) { + m_pIDirect3DDevice8->SetCursorPosition(XScreenSpace, YScreenSpace, Flags); +} + +BOOL __stdcall TraceDirect3DDevice8::ShowCursor(BOOL bShow) { + return (m_pIDirect3DDevice8->ShowCursor(bShow)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain) { + return (m_pIDirect3DDevice8->CreateAdditionalSwapChain(pPresentationParameters, pSwapChain)); +} + +HRESULT __stdcall TraceDirect3DDevice8::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) { + return (m_pIDirect3DDevice8->Reset(pPresentationParameters)); +} + +HRESULT __stdcall TraceDirect3DDevice8::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) +{ + // we may want to draw own things here before flipping surfaces + // ... draw own stuff ... + this->ShowWeAreHere(); + + // call original routine + HRESULT hres = m_pIDirect3DDevice8->Present( pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion); + + return (hres); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetBackBuffer(UINT BackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface8** ppBackBuffer) { + return (m_pIDirect3DDevice8->GetBackBuffer(BackBuffer, Type, ppBackBuffer)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetRasterStatus(D3DRASTER_STATUS* pRasterStatus) { + return (m_pIDirect3DDevice8->GetRasterStatus(pRasterStatus)); +} + +void __stdcall TraceDirect3DDevice8::SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp) +{ m_pIDirect3DDevice8->SetGammaRamp( Flags, pRamp);} + +void __stdcall TraceDirect3DDevice8::GetGammaRamp(D3DGAMMARAMP* pRamp) { + m_pIDirect3DDevice8->GetGammaRamp(pRamp); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture8** ppTexture) { + return (m_pIDirect3DDevice8->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture8** ppVolumeTexture) { + return (m_pIDirect3DDevice8->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture8** ppCubeTexture) { + return (m_pIDirect3DDevice8->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateVertexBuffer(UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer8** ppVertexBuffer) { + return (m_pIDirect3DDevice8->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer8** ppIndexBuffer) { + return (m_pIDirect3DDevice8->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, BOOL Lockable, IDirect3DSurface8** ppSurface) { + return (m_pIDirect3DDevice8->CreateRenderTarget(Width, Height, Format, MultiSample, Lockable, ppSurface)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, IDirect3DSurface8** ppSurface) { + return (m_pIDirect3DDevice8->CreateDepthStencilSurface(Width, Height, Format, MultiSample, ppSurface)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateImageSurface(UINT Width, UINT Height, D3DFORMAT Format, IDirect3DSurface8** ppSurface) { + return (m_pIDirect3DDevice8->CreateImageSurface(Width, Height, Format, ppSurface)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CopyRects( IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray) +{ return (m_pIDirect3DDevice8->CopyRects(pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray) );} + +HRESULT __stdcall TraceDirect3DDevice8::UpdateTexture(IDirect3DBaseTexture8* pSourceTexture, IDirect3DBaseTexture8* pDestinationTexture) { + return (m_pIDirect3DDevice8->UpdateTexture(pSourceTexture, pDestinationTexture)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetFrontBuffer(IDirect3DSurface8* pDestSurface) { + return (m_pIDirect3DDevice8->GetFrontBuffer(pDestSurface)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetRenderTarget(IDirect3DSurface8* pRenderTarget, IDirect3DSurface8* pNewZStencil) { + return (m_pIDirect3DDevice8->SetRenderTarget(pRenderTarget, pNewZStencil)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetRenderTarget(IDirect3DSurface8** ppRenderTarget) { + return (m_pIDirect3DDevice8->GetRenderTarget(ppRenderTarget)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetDepthStencilSurface(IDirect3DSurface8** ppZStencilSurface) { + return (m_pIDirect3DDevice8->GetDepthStencilSurface(ppZStencilSurface)); +} + +HRESULT __stdcall TraceDirect3DDevice8::BeginScene(void) { + return (m_pIDirect3DDevice8->BeginScene()); +} + +HRESULT __stdcall TraceDirect3DDevice8::EndScene(void) { + return (m_pIDirect3DDevice8->EndScene()); +} + +HRESULT __stdcall TraceDirect3DDevice8::Clear( DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) +{ return (m_pIDirect3DDevice8->Clear(Count, pRects, Flags, Color, Z, Stencil) );} + +HRESULT __stdcall TraceDirect3DDevice8::SetTransform( D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) +{ return (m_pIDirect3DDevice8->SetTransform(State, pMatrix) );} + +HRESULT __stdcall TraceDirect3DDevice8::GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) { + return (m_pIDirect3DDevice8->GetTransform(State, pMatrix)); +} + +HRESULT __stdcall TraceDirect3DDevice8::MultiplyTransform( D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) +{ return (m_pIDirect3DDevice8->MultiplyTransform( State,pMatrix) );} + +HRESULT __stdcall TraceDirect3DDevice8::SetViewport( CONST D3DVIEWPORT8* pViewport) +{ return (m_pIDirect3DDevice8->SetViewport( pViewport) );} + +HRESULT __stdcall TraceDirect3DDevice8::GetViewport(D3DVIEWPORT8* pViewport) { + return (m_pIDirect3DDevice8->GetViewport(pViewport)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetMaterial( CONST D3DMATERIAL8* pMaterial) +{ return (m_pIDirect3DDevice8->SetMaterial( pMaterial) );} + +HRESULT __stdcall TraceDirect3DDevice8::GetMaterial(D3DMATERIAL8* pMaterial) { + return (m_pIDirect3DDevice8->GetMaterial(pMaterial)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetLight( DWORD Index,CONST D3DLIGHT8* pLight) +{ return (m_pIDirect3DDevice8->SetLight(Index, pLight) );} + +HRESULT __stdcall TraceDirect3DDevice8::GetLight(DWORD Index, D3DLIGHT8* pLight) { + return (m_pIDirect3DDevice8->GetLight(Index, pLight)); +} + +HRESULT __stdcall TraceDirect3DDevice8::LightEnable(DWORD Index, BOOL Enable) { + return (m_pIDirect3DDevice8->LightEnable(Index, Enable)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetLightEnable(DWORD Index, BOOL* pEnable) { + return (m_pIDirect3DDevice8->GetLightEnable(Index, pEnable)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetClipPlane(DWORD Index, CONST float* pPlane) { + return (m_pIDirect3DDevice8->SetClipPlane(Index, pPlane)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetClipPlane(DWORD Index, float* pPlane) { + return (m_pIDirect3DDevice8->GetClipPlane(Index, pPlane)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetRenderState(D3DRENDERSTATETYPE State, DWORD Value) { + return (m_pIDirect3DDevice8->SetRenderState(State, Value)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetRenderState(D3DRENDERSTATETYPE State, DWORD* pValue) { + return (m_pIDirect3DDevice8->GetRenderState(State, pValue)); +} + +HRESULT __stdcall TraceDirect3DDevice8::BeginStateBlock(void) { + return (m_pIDirect3DDevice8->BeginStateBlock()); +} + +HRESULT __stdcall TraceDirect3DDevice8::EndStateBlock(DWORD* pToken) { + return (m_pIDirect3DDevice8->EndStateBlock(pToken)); +} + +HRESULT __stdcall TraceDirect3DDevice8::ApplyStateBlock(DWORD Token) { + return (m_pIDirect3DDevice8->ApplyStateBlock(Token)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CaptureStateBlock(DWORD Token) { + return (m_pIDirect3DDevice8->CaptureStateBlock(Token)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DeleteStateBlock(DWORD Token) { + return (m_pIDirect3DDevice8->DeleteStateBlock(Token)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateStateBlock(D3DSTATEBLOCKTYPE Type, DWORD* pToken) { + return (m_pIDirect3DDevice8->CreateStateBlock(Type, pToken)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetClipStatus( CONST D3DCLIPSTATUS8* pClipStatus) +{ return (m_pIDirect3DDevice8->SetClipStatus( pClipStatus) );} + +HRESULT __stdcall TraceDirect3DDevice8::GetClipStatus(D3DCLIPSTATUS8* pClipStatus) { + return (m_pIDirect3DDevice8->GetClipStatus(pClipStatus)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetTexture(DWORD Stage, IDirect3DBaseTexture8** ppTexture) { + return (m_pIDirect3DDevice8->GetTexture(Stage, ppTexture)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetTexture(DWORD Stage, IDirect3DBaseTexture8* pTexture) { + return (m_pIDirect3DDevice8->SetTexture(Stage, pTexture)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) { + return (m_pIDirect3DDevice8->GetTextureStageState(Stage, Type, pValue)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) { + return (m_pIDirect3DDevice8->SetTextureStageState(Stage, Type, Value)); +} + +HRESULT __stdcall TraceDirect3DDevice8::ValidateDevice(DWORD* pNumPasses) { + return (m_pIDirect3DDevice8->ValidateDevice(pNumPasses)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetInfo(DWORD DevInfoID, void* pDevInfoStruct, DWORD DevInfoStructSize) { + return (m_pIDirect3DDevice8->GetInfo(DevInfoID, pDevInfoStruct, DevInfoStructSize)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetPaletteEntries( UINT PaletteNumber,CONST PALETTEENTRY* pEntries) +{ return (m_pIDirect3DDevice8->SetPaletteEntries(PaletteNumber, pEntries) );} + +HRESULT __stdcall TraceDirect3DDevice8::GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY* pEntries) { + return (m_pIDirect3DDevice8->GetPaletteEntries(PaletteNumber, pEntries)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetCurrentTexturePalette(UINT PaletteNumber) { + return (m_pIDirect3DDevice8->SetCurrentTexturePalette(PaletteNumber)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetCurrentTexturePalette(UINT *PaletteNumber) { + return (m_pIDirect3DDevice8->GetCurrentTexturePalette(PaletteNumber)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { + return (m_pIDirect3DDevice8->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DrawIndexedPrimitive(D3DPRIMITIVETYPE Type, UINT minIndex, UINT NumVertices, UINT startIndex, UINT primCount) { + return (m_pIDirect3DDevice8->DrawIndexedPrimitive(Type, minIndex, NumVertices, startIndex, primCount)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + return (m_pIDirect3DDevice8->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertexIndices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + return (m_pIDirect3DDevice8->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride)); +} + +HRESULT __stdcall TraceDirect3DDevice8::ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer8* pDestBuffer, DWORD Flags) { + return (m_pIDirect3DDevice8->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer, Flags)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreateVertexShader( CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage) +{ return (m_pIDirect3DDevice8->CreateVertexShader( pDeclaration, pFunction, pHandle, Usage));} + +HRESULT __stdcall TraceDirect3DDevice8::SetVertexShader(DWORD Handle) { + return (m_pIDirect3DDevice8->SetVertexShader(Handle)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetVertexShader(DWORD* pHandle) { + return (m_pIDirect3DDevice8->GetVertexShader(pHandle)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DeleteVertexShader(DWORD Handle) { + return (m_pIDirect3DDevice8->DeleteVertexShader(Handle)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetVertexShaderConstant(DWORD Register, CONST void* pConstantData, DWORD ConstantCount) { + return (m_pIDirect3DDevice8->SetVertexShaderConstant(Register, pConstantData, ConstantCount)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetVertexShaderConstant(DWORD Register, void* pConstantData, DWORD ConstantCount) { + return (m_pIDirect3DDevice8->GetVertexShaderConstant(Register, pConstantData, ConstantCount)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetVertexShaderDeclaration(DWORD Handle, void* pData, DWORD* pSizeOfData) { + return (m_pIDirect3DDevice8->GetVertexShaderDeclaration(Handle, pData, pSizeOfData)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetVertexShaderFunction(DWORD Handle, void* pData, DWORD* pSizeOfData) { + return (m_pIDirect3DDevice8->GetVertexShaderFunction(Handle, pData, pSizeOfData)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer8* pStreamData, UINT Stride) { + return (m_pIDirect3DDevice8->SetStreamSource(StreamNumber, pStreamData, Stride)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer8** ppStreamData, UINT* pStride) { + return (m_pIDirect3DDevice8->GetStreamSource(StreamNumber, ppStreamData, pStride)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetIndices(IDirect3DIndexBuffer8* pIndexData, UINT BaseVertexIndex) { + return (m_pIDirect3DDevice8->SetIndices(pIndexData, BaseVertexIndex)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetIndices(IDirect3DIndexBuffer8** ppIndexData, UINT* pBaseVertexIndex) { + return (m_pIDirect3DDevice8->GetIndices(ppIndexData, pBaseVertexIndex)); +} + +HRESULT __stdcall TraceDirect3DDevice8::CreatePixelShader( CONST DWORD* pFunction,DWORD* pHandle) +{ return (m_pIDirect3DDevice8->CreatePixelShader( pFunction, pHandle));} + +HRESULT __stdcall TraceDirect3DDevice8::SetPixelShader(DWORD Handle) { + return (m_pIDirect3DDevice8->SetPixelShader(Handle)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetPixelShader(DWORD* pHandle) { + return (m_pIDirect3DDevice8->GetPixelShader(pHandle)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DeletePixelShader(DWORD Handle) { + return (m_pIDirect3DDevice8->DeletePixelShader(Handle)); +} + +HRESULT __stdcall TraceDirect3DDevice8::SetPixelShaderConstant(DWORD Register, CONST void* pConstantData, DWORD ConstantCount) { + return (m_pIDirect3DDevice8->SetPixelShaderConstant(Register, pConstantData, ConstantCount)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetPixelShaderConstant(DWORD Register, void* pConstantData, DWORD ConstantCount) { + return (m_pIDirect3DDevice8->GetPixelShaderConstant(Register, pConstantData, ConstantCount)); +} + +HRESULT __stdcall TraceDirect3DDevice8::GetPixelShaderFunction(DWORD Handle, void* pData, DWORD* pSizeOfData) { + return (m_pIDirect3DDevice8->GetPixelShaderFunction(Handle, pData, pSizeOfData)); +} + +HRESULT __stdcall TraceDirect3DDevice8::DrawRectPatch( UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) +{ return (m_pIDirect3DDevice8->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo) );} + +HRESULT __stdcall TraceDirect3DDevice8::DrawTriPatch( UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) +{ return (m_pIDirect3DDevice8->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo) );} + +HRESULT __stdcall TraceDirect3DDevice8::DeletePatch(UINT Handle) { + return (m_pIDirect3DDevice8->DeletePatch(Handle)); +} + +// This is our test function +void TraceDirect3DDevice8::ShowWeAreHere(void) { + D3DRECT rec = { 1, 1, 50, 50 }; + m_pIDirect3DDevice8->Clear(1, &rec, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255,255,255,0), 0, 0); +} diff --git a/d3d8/idirect3d_device8.hpp b/d3d8/idirect3d_device8.hpp new file mode 100644 index 0000000..d9c3d35 --- /dev/null +++ b/d3d8/idirect3d_device8.hpp @@ -0,0 +1,118 @@ +// TraceDirect3DDevice8.h +#pragma once + +class TraceDirect3DDevice8: public IDirect3DDevice8 { +public: + + TraceDirect3DDevice8(IDirect3DDevice8* pOriginal); + virtual ~TraceDirect3DDevice8(); + + // START: The original DX8.1a function definitions + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj); + ULONG __stdcall AddRef(void); + ULONG __stdcall Release(void); + HRESULT __stdcall TestCooperativeLevel(void); + UINT __stdcall GetAvailableTextureMem(void); + HRESULT __stdcall ResourceManagerDiscardBytes(DWORD Bytes); + HRESULT __stdcall GetDirect3D(IDirect3D8** ppD3D8); + HRESULT __stdcall GetDeviceCaps(D3DCAPS8* pCaps); + HRESULT __stdcall GetDisplayMode(D3DDISPLAYMODE* pMode); + HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters); + HRESULT __stdcall SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface8* pCursorBitmap); + void __stdcall SetCursorPosition(int XScreenSpace, int YScreenSpace, DWORD Flags); + BOOL __stdcall ShowCursor(BOOL bShow); + HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain8** pSwapChain); + HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters); + HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion); + HRESULT __stdcall GetBackBuffer(UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer); + HRESULT __stdcall GetRasterStatus(D3DRASTER_STATUS* pRasterStatus); + void __stdcall SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp); + void __stdcall GetGammaRamp(D3DGAMMARAMP* pRamp); + HRESULT __stdcall CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture); + HRESULT __stdcall CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture); + HRESULT __stdcall CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture); + HRESULT __stdcall CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer); + HRESULT __stdcall CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer); + HRESULT __stdcall CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface); + HRESULT __stdcall CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface); + HRESULT __stdcall CreateImageSurface(UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface); + HRESULT __stdcall CopyRects(IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray); + HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture); + HRESULT __stdcall GetFrontBuffer(IDirect3DSurface8* pDestSurface); + HRESULT __stdcall SetRenderTarget(IDirect3DSurface8* pRenderTarget,IDirect3DSurface8* pNewZStencil); + HRESULT __stdcall GetRenderTarget(IDirect3DSurface8** ppRenderTarget); + HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface8** ppZStencilSurface); + HRESULT __stdcall BeginScene(THIS); + HRESULT __stdcall EndScene(THIS); + HRESULT __stdcall Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil); + HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix); + HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix); + HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix); + HRESULT __stdcall SetViewport(CONST D3DVIEWPORT8* pViewport); + HRESULT __stdcall GetViewport(D3DVIEWPORT8* pViewport); + HRESULT __stdcall SetMaterial(CONST D3DMATERIAL8* pMaterial); + HRESULT __stdcall GetMaterial(D3DMATERIAL8* pMaterial); + HRESULT __stdcall SetLight(DWORD Index,CONST D3DLIGHT8* pLight); + HRESULT __stdcall GetLight(DWORD Index,D3DLIGHT8* pLight); + HRESULT __stdcall LightEnable(DWORD Index,BOOL Enable); + HRESULT __stdcall GetLightEnable(DWORD Index,BOOL* pEnable); + HRESULT __stdcall SetClipPlane(DWORD Index,CONST float* pPlane); + HRESULT __stdcall GetClipPlane(DWORD Index,float* pPlane); + HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State,DWORD Value); + HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue); + HRESULT __stdcall BeginStateBlock(THIS); + HRESULT __stdcall EndStateBlock(DWORD* pToken); + HRESULT __stdcall ApplyStateBlock(DWORD Token); + HRESULT __stdcall CaptureStateBlock(DWORD Token); + HRESULT __stdcall DeleteStateBlock(DWORD Token); + HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type,DWORD* pToken); + HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS8* pClipStatus); + HRESULT __stdcall GetClipStatus(D3DCLIPSTATUS8* pClipStatus); + HRESULT __stdcall GetTexture(DWORD Stage,IDirect3DBaseTexture8** ppTexture); + HRESULT __stdcall SetTexture(DWORD Stage,IDirect3DBaseTexture8* pTexture); + HRESULT __stdcall GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue); + HRESULT __stdcall SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value); + HRESULT __stdcall ValidateDevice(DWORD* pNumPasses); + HRESULT __stdcall GetInfo(DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize); + HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries); + HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries); + HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber); + HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber); + HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount); + HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE Type,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount); + HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride); + HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride); + HRESULT __stdcall ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags); + HRESULT __stdcall CreateVertexShader(CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage); + HRESULT __stdcall SetVertexShader(DWORD Handle); + HRESULT __stdcall GetVertexShader(DWORD* pHandle); + HRESULT __stdcall DeleteVertexShader(DWORD Handle); + HRESULT __stdcall SetVertexShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount); + HRESULT __stdcall GetVertexShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount); + HRESULT __stdcall GetVertexShaderDeclaration(DWORD Handle,void* pData,DWORD* pSizeOfData); + HRESULT __stdcall GetVertexShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData); + HRESULT __stdcall SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride); + HRESULT __stdcall GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride); + HRESULT __stdcall SetIndices(IDirect3DIndexBuffer8* pIndexData,UINT BaseVertexIndex); + HRESULT __stdcall GetIndices(IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex); + HRESULT __stdcall CreatePixelShader(CONST DWORD* pFunction,DWORD* pHandle); + HRESULT __stdcall SetPixelShader(DWORD Handle); + HRESULT __stdcall GetPixelShader(DWORD* pHandle); + HRESULT __stdcall DeletePixelShader(DWORD Handle); + HRESULT __stdcall SetPixelShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount); + HRESULT __stdcall GetPixelShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount); + HRESULT __stdcall GetPixelShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData); + HRESULT __stdcall DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo); + HRESULT __stdcall DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo); + HRESULT __stdcall DeletePatch(UINT Handle); + // END: The original DX8.1a function definitions + +private: + + IDirect3DDevice8 *m_pIDirect3DDevice8; + + // This is our test function + void ShowWeAreHere(void); + +}; + diff --git a/d3d8/stdafx.h b/d3d8/stdafx.h new file mode 100644 index 0000000..f2662ee --- /dev/null +++ b/d3d8/stdafx.h @@ -0,0 +1,12 @@ +// stdafx.h +#pragma once + + +#define WIN32_LEAN_AND_MEAN +#include +#include + +#include + +#include "idirect3d8.hpp" +#include "idirect3d_device8.hpp" diff --git a/d3d9/SConscript b/d3d9/SConscript new file mode 100644 index 0000000..6c5af22 --- /dev/null +++ b/d3d9/SConscript @@ -0,0 +1,12 @@ +Import('env') + +env.SharedLibrary( + target = 'd3d9.dll', + source = [ + 'd3d9.def', + 'dllmain.cpp', + 'idirect3d9.cpp', + 'idirect3d_device9.cpp', + 'idirect3d_swapchain9.cpp', + ] +) diff --git a/d3d9/d3d9.def b/d3d9/d3d9.def new file mode 100644 index 0000000..d74db14 --- /dev/null +++ b/d3d9/d3d9.def @@ -0,0 +1,4 @@ +LIBRARY "d3d9" + +EXPORTS + Direct3DCreate9 @1 diff --git a/d3d9/dllmain.cpp b/d3d9/dllmain.cpp new file mode 100644 index 0000000..9a8878b --- /dev/null +++ b/d3d9/dllmain.cpp @@ -0,0 +1,101 @@ +// proxydll.cpp +#include "stdafx.h" +#include "dllmain.hpp" + +// global variables +#pragma data_seg (".d3d9_shared") +TraceDirect3DSwapChain9* gl_pmyIDirect3DSwapChain9; +TraceDirect3DDevice9* gl_pmyIDirect3DDevice9; +TraceDirect3D9* gl_pmyIDirect3D9; +HINSTANCE gl_hOriginalDll; +HINSTANCE gl_hThisInstance; +#pragma data_seg () + +BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) +{ + // to avoid compiler lvl4 warnings + LPVOID lpDummy = lpReserved; + lpDummy = NULL; + + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: InitInstance(hModule); break; + case DLL_PROCESS_DETACH: ExitInstance(); break; + + case DLL_THREAD_ATTACH: break; + case DLL_THREAD_DETACH: break; + } + return TRUE; +} + +// Exported function (faking d3d9.dll's one-and-only export) +IDirect3D9* WINAPI Direct3DCreate9(UINT SDKVersion) +{ + if (!gl_hOriginalDll) LoadOriginalDll(); // looking for the "right d3d9.dll" + + // Hooking IDirect3D Object from Original Library + typedef IDirect3D9 *(WINAPI* D3D9_Type)(UINT SDKVersion); + D3D9_Type D3DCreate9_fn = (D3D9_Type) GetProcAddress( gl_hOriginalDll, "Direct3DCreate9"); + + // Debug + if (!D3DCreate9_fn) + { + OutputDebugString(_T("PROXYDLL: Pointer to original D3DCreate9 function not received ERROR ****\r\n")); + ::ExitProcess(0); // exit the hard way + } + + // Request pointer from Original Dll. + IDirect3D9 *pIDirect3D9_orig = D3DCreate9_fn(SDKVersion); + + // Create my IDirect3D8 object and store pointer to original object there. + // note: the object will delete itself once Ref count is zero (similar to COM objects) + gl_pmyIDirect3D9 = new TraceDirect3D9(pIDirect3D9_orig); + + // Return pointer to hooking Object instead of "real one" + return (gl_pmyIDirect3D9); +} + +void InitInstance(HANDLE hModule) { + OutputDebugString(_T("PROXYDLL: InitInstance called.\r\n")); + + // Initialisation + gl_hOriginalDll = NULL; + gl_hThisInstance = NULL; + gl_pmyIDirect3D9 = NULL; + gl_pmyIDirect3DDevice9 = NULL; + gl_pmyIDirect3DSwapChain9 = NULL; + + // Storing Instance handle into global var + gl_hThisInstance = (HINSTANCE) hModule; +} + +void LoadOriginalDll(void) { + TCHAR buffer[MAX_PATH]; + + // Getting path to system dir and to d3d8.dll + ::GetSystemDirectory(buffer, MAX_PATH); + + // Append dll name + _tcscat(buffer, _T("\\d3d9.dll")); + + // try to load the system's d3d9.dll, if pointer empty + if (!gl_hOriginalDll) + gl_hOriginalDll = ::LoadLibrary(buffer); + + // Debug + if (!gl_hOriginalDll) { + OutputDebugString(_T("PROXYDLL: Original d3d9.dll not loaded ERROR ****\r\n")); + ::ExitProcess(0); // exit the hard way + } +} + +void ExitInstance() { + OutputDebugString(_T("PROXYDLL: ExitInstance called.\r\n")); + + // Release the system's d3d9.dll + if (gl_hOriginalDll) { + ::FreeLibrary(gl_hOriginalDll); + gl_hOriginalDll = NULL; + } +} + diff --git a/d3d9/dllmain.hpp b/d3d9/dllmain.hpp new file mode 100644 index 0000000..5a4528b --- /dev/null +++ b/d3d9/dllmain.hpp @@ -0,0 +1,10 @@ +// proxydll.h +#pragma once + +// Exported function +IDirect3D9* WINAPI Direct3DCreate9 (UINT SDKVersion); + +// regular functions +void InitInstance(HANDLE hModule); +void ExitInstance(void); +void LoadOriginalDll(void); \ No newline at end of file diff --git a/d3d9/idirect3d9.cpp b/d3d9/idirect3d9.cpp new file mode 100644 index 0000000..c8d4596 --- /dev/null +++ b/d3d9/idirect3d9.cpp @@ -0,0 +1,114 @@ +#include "StdAfx.h" + +TraceDirect3D9::TraceDirect3D9(IDirect3D9 *pOriginal) { + m_pIDirect3D9 = pOriginal; +} + +TraceDirect3D9::~TraceDirect3D9(void) { +} + +HRESULT __stdcall TraceDirect3D9::QueryInterface(REFIID riid, void** ppvObj) { + *ppvObj = NULL; + + // call this to increase AddRef at original object + // and to check if such an interface is there + + HRESULT hRes = m_pIDirect3D9->QueryInterface(riid, ppvObj); + + if (hRes == NOERROR) // if OK, send our "fake" address + { + *ppvObj = this; + } + + return hRes; +} + +ULONG __stdcall TraceDirect3D9::AddRef(void) { + return (m_pIDirect3D9->AddRef()); +} + +ULONG __stdcall TraceDirect3D9::Release(void) { + extern TraceDirect3D9* gl_pmyIDirect3D9; + + // call original routine + ULONG count = m_pIDirect3D9->Release(); + + // in case no further Ref is there, the Original Object has deleted itself + // so do we here + if (count == 0) { + gl_pmyIDirect3D9 = NULL; + delete (this); + } + + return (count); +} + +HRESULT __stdcall TraceDirect3D9::RegisterSoftwareDevice(void* pInitializeFunction) { + return (m_pIDirect3D9->RegisterSoftwareDevice(pInitializeFunction)); +} + +UINT __stdcall TraceDirect3D9::GetAdapterCount(void) { + return (m_pIDirect3D9->GetAdapterCount()); +} + +HRESULT __stdcall TraceDirect3D9::GetAdapterIdentifier(UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier) { + return (m_pIDirect3D9->GetAdapterIdentifier(Adapter, Flags, pIdentifier)); +} + +UINT __stdcall TraceDirect3D9::GetAdapterModeCount(UINT Adapter, D3DFORMAT Format) { + return (m_pIDirect3D9->GetAdapterModeCount(Adapter, Format)); +} + +HRESULT __stdcall TraceDirect3D9::EnumAdapterModes(UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE* pMode) { + return (m_pIDirect3D9->EnumAdapterModes(Adapter, Format, Mode, pMode)); +} + +HRESULT __stdcall TraceDirect3D9::GetAdapterDisplayMode(UINT Adapter, D3DDISPLAYMODE* pMode) { + return (m_pIDirect3D9->GetAdapterDisplayMode(Adapter, pMode)); +} + +HRESULT __stdcall TraceDirect3D9::CheckDeviceType(UINT iAdapter, D3DDEVTYPE DevType, D3DFORMAT DisplayFormat, D3DFORMAT BackBufferFormat, BOOL bWindowed) { + return (m_pIDirect3D9->CheckDeviceType(iAdapter, DevType, DisplayFormat, BackBufferFormat, bWindowed)); +} + +HRESULT __stdcall TraceDirect3D9::CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat) { + return (m_pIDirect3D9->CheckDeviceFormat(Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat)); +} + +HRESULT __stdcall TraceDirect3D9::CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) { + return (m_pIDirect3D9->CheckDeviceMultiSampleType(Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType, pQualityLevels)); +} + +HRESULT __stdcall TraceDirect3D9::CheckDepthStencilMatch(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat) { + return (m_pIDirect3D9->CheckDepthStencilMatch(Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat)); +} + +HRESULT __stdcall TraceDirect3D9::CheckDeviceFormatConversion(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat) { + return (m_pIDirect3D9->CheckDeviceFormatConversion(Adapter, DeviceType, SourceFormat, TargetFormat)); +} + +HRESULT __stdcall TraceDirect3D9::GetDeviceCaps(UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps) { + return (m_pIDirect3D9->GetDeviceCaps(Adapter, DeviceType, pCaps)); +} + +HMONITOR __stdcall TraceDirect3D9::GetAdapterMonitor(UINT Adapter) { + return (m_pIDirect3D9->GetAdapterMonitor(Adapter)); +} + +HRESULT __stdcall TraceDirect3D9::CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DDevice9** ppReturnedDeviceInterface) { + // global var + extern TraceDirect3DDevice9* gl_pmyIDirect3DDevice9; + + // we intercept this call and provide our own "fake" Device Object + HRESULT hres = m_pIDirect3D9->CreateDevice(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface); + + // Create our own Device object and store it in global pointer + // note: the object will delete itself once Ref count is zero (similar to COM objects) + gl_pmyIDirect3DDevice9 = new TraceDirect3DDevice9(*ppReturnedDeviceInterface); + + // store our pointer (the fake one) for returning it to the calling progam + *ppReturnedDeviceInterface = gl_pmyIDirect3DDevice9; + + return (hres); +} + diff --git a/d3d9/idirect3d9.hpp b/d3d9/idirect3d9.hpp new file mode 100644 index 0000000..af67442 --- /dev/null +++ b/d3d9/idirect3d9.hpp @@ -0,0 +1,31 @@ +#pragma once + +class TraceDirect3D9 : public IDirect3D9 +{ +public: + TraceDirect3D9(IDirect3D9 *pOriginal); + virtual ~TraceDirect3D9(void); + + // The original DX9 function definitions + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj); + ULONG __stdcall AddRef(void); + ULONG __stdcall Release(void); + HRESULT __stdcall RegisterSoftwareDevice(void* pInitializeFunction); + UINT __stdcall GetAdapterCount(void); + HRESULT __stdcall GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier) ; + UINT __stdcall GetAdapterModeCount(UINT Adapter, D3DFORMAT Format); + HRESULT __stdcall EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode) ; + HRESULT __stdcall GetAdapterDisplayMode( UINT Adapter,D3DDISPLAYMODE* pMode) ; + HRESULT __stdcall CheckDeviceType(UINT iAdapter,D3DDEVTYPE DevType,D3DFORMAT DisplayFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed) ; + HRESULT __stdcall CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat) ; + HRESULT __stdcall CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels) ; + HRESULT __stdcall CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat) ; + HRESULT __stdcall CheckDeviceFormatConversion(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat); + HRESULT __stdcall GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps) ; + HMONITOR __stdcall GetAdapterMonitor(UINT Adapter) ; + HRESULT __stdcall CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface) ; + // The original DX9 function definitions + +private: + IDirect3D9 *m_pIDirect3D9; +}; diff --git a/d3d9/idirect3d_device9.cpp b/d3d9/idirect3d_device9.cpp new file mode 100644 index 0000000..bf209e0 --- /dev/null +++ b/d3d9/idirect3d_device9.cpp @@ -0,0 +1,572 @@ +#include "StdAfx.h" + +TraceDirect3DDevice9::TraceDirect3DDevice9(IDirect3DDevice9* pOriginal) { + m_pIDirect3DDevice9 = pOriginal; // store the pointer to original object +} + +TraceDirect3DDevice9::~TraceDirect3DDevice9(void) { +} + +HRESULT TraceDirect3DDevice9::QueryInterface(REFIID riid, void** ppvObj) { + // check if original dll can provide interface. then send *our* address + *ppvObj = NULL; + + HRESULT hRes = m_pIDirect3DDevice9->QueryInterface(riid, ppvObj); + + if (hRes == NOERROR) { + *ppvObj = this; + } + + return hRes; +} + +ULONG TraceDirect3DDevice9::AddRef(void) { + return (m_pIDirect3DDevice9->AddRef()); +} + +ULONG TraceDirect3DDevice9::Release(void) { + // ATTENTION: This is a booby-trap ! Watch out ! + // If we create our own sprites, surfaces, etc. (thus increasing the ref counter + // by external action), we need to delete that objects before calling the original + // Release function + + // global var + extern TraceDirect3DDevice9* gl_pmyIDirect3DDevice9; + + // release/delete own objects + // ..... + + // Calling original function now + ULONG count = m_pIDirect3DDevice9->Release(); + + if (count == 0) { + // now, the Original Object has deleted itself, so do we here + gl_pmyIDirect3DDevice9 = NULL; + delete (this); // destructor will be called automatically + } + + return (count); +} + +HRESULT TraceDirect3DDevice9::TestCooperativeLevel(void) { + return (m_pIDirect3DDevice9->TestCooperativeLevel()); +} + +UINT TraceDirect3DDevice9::GetAvailableTextureMem(void) { + return (m_pIDirect3DDevice9->GetAvailableTextureMem()); +} + +HRESULT TraceDirect3DDevice9::EvictManagedResources(void) { + return (m_pIDirect3DDevice9->EvictManagedResources()); +} + +HRESULT TraceDirect3DDevice9::GetDirect3D(IDirect3D9** ppD3D9) { + return (m_pIDirect3DDevice9->GetDirect3D(ppD3D9)); +} + +HRESULT TraceDirect3DDevice9::GetDeviceCaps(D3DCAPS9* pCaps) { + return (m_pIDirect3DDevice9->GetDeviceCaps(pCaps)); +} + +HRESULT TraceDirect3DDevice9::GetDisplayMode(UINT iSwapChain, D3DDISPLAYMODE* pMode) { + return (m_pIDirect3DDevice9->GetDisplayMode(iSwapChain, pMode)); +} + +HRESULT TraceDirect3DDevice9::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) { + return (m_pIDirect3DDevice9->GetCreationParameters(pParameters)); +} + +HRESULT TraceDirect3DDevice9::SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap) { + return (m_pIDirect3DDevice9->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap)); +} + +void TraceDirect3DDevice9::SetCursorPosition(int X, int Y, DWORD Flags) { + return (m_pIDirect3DDevice9->SetCursorPosition(X, Y, Flags)); +} + +BOOL TraceDirect3DDevice9::ShowCursor(BOOL bShow) { + return (m_pIDirect3DDevice9->ShowCursor(bShow)); +} + +HRESULT TraceDirect3DDevice9::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain) { + return (m_pIDirect3DDevice9->CreateAdditionalSwapChain(pPresentationParameters, pSwapChain)); +} + +HRESULT TraceDirect3DDevice9::GetSwapChain(UINT iSwapChain, IDirect3DSwapChain9** pSwapChain) { + // global var + extern TraceDirect3DSwapChain9* gl_pmyIDirect3DSwapChain9; + + // We only cover swapchain 0 + if (iSwapChain != 0) + return (m_pIDirect3DDevice9->GetSwapChain(iSwapChain, pSwapChain)); + + if (gl_pmyIDirect3DSwapChain9) { + *pSwapChain = gl_pmyIDirect3DSwapChain9; + return (D3D_OK); + } + + // we intercept this call and provide our own "fake" SwapChain Object + IDirect3DSwapChain9* pOriginal = NULL; + HRESULT hres = m_pIDirect3DDevice9->GetSwapChain(iSwapChain, &pOriginal); + + // Create our own SwapChain object and store it in global pointer + // note: the object will delete itself once Ref count is zero (similar to COM objects) + gl_pmyIDirect3DSwapChain9 + = new TraceDirect3DSwapChain9(pOriginal, m_pIDirect3DDevice9); + + // store our pointer (the fake one) for returning it to the calling progam + *pSwapChain = gl_pmyIDirect3DSwapChain9; + + return (hres); +} + +UINT TraceDirect3DDevice9::GetNumberOfSwapChains(void) { + return (m_pIDirect3DDevice9->GetNumberOfSwapChains()); +} + +HRESULT TraceDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) { + return (m_pIDirect3DDevice9->Reset(pPresentationParameters)); +} + +HRESULT TraceDirect3DDevice9::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) +{ + // we may want to draw own things here before flipping surfaces + // ... draw own stuff ... + this->ShowWeAreHere(); + + // call original routine + HRESULT hres = m_pIDirect3DDevice9->Present( pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion); + + return (hres); +} + +HRESULT TraceDirect3DDevice9::GetBackBuffer(UINT iSwapChain, UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) { + return (m_pIDirect3DDevice9->GetBackBuffer(iSwapChain, iBackBuffer, Type, ppBackBuffer)); +} + +HRESULT TraceDirect3DDevice9::GetRasterStatus(UINT iSwapChain, D3DRASTER_STATUS* pRasterStatus) { + return (m_pIDirect3DDevice9->GetRasterStatus(iSwapChain, pRasterStatus)); +} + +HRESULT TraceDirect3DDevice9::SetDialogBoxMode(BOOL bEnableDialogs) { + return (m_pIDirect3DDevice9->SetDialogBoxMode(bEnableDialogs)); +} + +void TraceDirect3DDevice9::SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp) +{ + return(m_pIDirect3DDevice9->SetGammaRamp(iSwapChain,Flags,pRamp)); +} + +void TraceDirect3DDevice9::GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp) { + return (m_pIDirect3DDevice9->GetGammaRamp(iSwapChain, pRamp)); +} + +HRESULT TraceDirect3DDevice9::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::CreateVertexBuffer(UINT Length, DWORD Usage, DWORD FVF, D3DPOOL Pool, IDirect3DVertexBuffer9** ppVertexBuffer, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::CreateIndexBuffer(UINT Length, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DIndexBuffer9** ppIndexBuffer, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::CreateRenderTarget(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Lockable, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateRenderTarget(Width, Height, Format, MultiSample, MultisampleQuality, Lockable, ppSurface, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::CreateDepthStencilSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DMULTISAMPLE_TYPE MultiSample, DWORD MultisampleQuality, BOOL Discard, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateDepthStencilSurface(Width, Height, Format, MultiSample, MultisampleQuality, Discard, ppSurface, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::UpdateSurface(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint) +{ + return(m_pIDirect3DDevice9->UpdateSurface(pSourceSurface,pSourceRect,pDestinationSurface,pDestPoint)); +} + +HRESULT TraceDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTexture, IDirect3DBaseTexture9* pDestinationTexture) { + return (m_pIDirect3DDevice9->UpdateTexture(pSourceTexture, pDestinationTexture)); +} + +HRESULT TraceDirect3DDevice9::GetRenderTargetData(IDirect3DSurface9* pRenderTarget, IDirect3DSurface9* pDestSurface) { + return (m_pIDirect3DDevice9->GetRenderTargetData(pRenderTarget, pDestSurface)); +} + +HRESULT TraceDirect3DDevice9::GetFrontBufferData(UINT iSwapChain, IDirect3DSurface9* pDestSurface) { + return (m_pIDirect3DDevice9->GetFrontBufferData(iSwapChain, pDestSurface)); +} + +HRESULT TraceDirect3DDevice9::StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter) +{ + return(m_pIDirect3DDevice9->StretchRect(pSourceSurface,pSourceRect,pDestSurface,pDestRect,Filter)); +} + +HRESULT TraceDirect3DDevice9::ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color) +{ + return(m_pIDirect3DDevice9->ColorFill(pSurface,pRect,color)); +} + +HRESULT TraceDirect3DDevice9::CreateOffscreenPlainSurface(UINT Width, UINT Height, D3DFORMAT Format, D3DPOOL Pool, IDirect3DSurface9** ppSurface, HANDLE* pSharedHandle) { + return (m_pIDirect3DDevice9->CreateOffscreenPlainSurface(Width, Height, Format, Pool, ppSurface, pSharedHandle)); +} + +HRESULT TraceDirect3DDevice9::SetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget) { + return (m_pIDirect3DDevice9->SetRenderTarget(RenderTargetIndex, pRenderTarget)); +} + +HRESULT TraceDirect3DDevice9::GetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9** ppRenderTarget) { + return (m_pIDirect3DDevice9->GetRenderTarget(RenderTargetIndex, ppRenderTarget)); +} + +HRESULT TraceDirect3DDevice9::SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil) { + return (m_pIDirect3DDevice9->SetDepthStencilSurface(pNewZStencil)); +} + +HRESULT TraceDirect3DDevice9::GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface) { + return (m_pIDirect3DDevice9->GetDepthStencilSurface(ppZStencilSurface)); +} + +HRESULT TraceDirect3DDevice9::BeginScene(void) { + return (m_pIDirect3DDevice9->BeginScene()); +} + +HRESULT TraceDirect3DDevice9::EndScene(void) { + return (m_pIDirect3DDevice9->EndScene()); +} + +HRESULT TraceDirect3DDevice9::Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) +{ + return(m_pIDirect3DDevice9->Clear(Count,pRects,Flags,Color,Z,Stencil)); +} + +HRESULT TraceDirect3DDevice9::SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) +{ + return(m_pIDirect3DDevice9->SetTransform(State,pMatrix)); +} + +HRESULT TraceDirect3DDevice9::GetTransform(D3DTRANSFORMSTATETYPE State, D3DMATRIX* pMatrix) { + return (m_pIDirect3DDevice9->GetTransform(State, pMatrix)); +} + +HRESULT TraceDirect3DDevice9::MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) +{ + return(m_pIDirect3DDevice9->MultiplyTransform(State,pMatrix)); +} + +HRESULT TraceDirect3DDevice9::SetViewport(CONST D3DVIEWPORT9* pViewport) +{ + return(m_pIDirect3DDevice9->SetViewport(pViewport)); +} + +HRESULT TraceDirect3DDevice9::GetViewport(D3DVIEWPORT9* pViewport) { + return (m_pIDirect3DDevice9->GetViewport(pViewport)); +} + +HRESULT TraceDirect3DDevice9::SetMaterial(CONST D3DMATERIAL9* pMaterial) +{ + return(m_pIDirect3DDevice9->SetMaterial(pMaterial)); +} + +HRESULT TraceDirect3DDevice9::GetMaterial(D3DMATERIAL9* pMaterial) { + return (m_pIDirect3DDevice9->GetMaterial(pMaterial)); +} + +HRESULT TraceDirect3DDevice9::SetLight(DWORD Index,CONST D3DLIGHT9* pLight) +{ + return(m_pIDirect3DDevice9->SetLight(Index,pLight)); +} + +HRESULT TraceDirect3DDevice9::GetLight(DWORD Index, D3DLIGHT9* pLight) { + return (m_pIDirect3DDevice9->GetLight(Index, pLight)); +} + +HRESULT TraceDirect3DDevice9::LightEnable(DWORD Index, BOOL Enable) { + return (m_pIDirect3DDevice9->LightEnable(Index, Enable)); +} + +HRESULT TraceDirect3DDevice9::GetLightEnable(DWORD Index, BOOL* pEnable) { + return (m_pIDirect3DDevice9->GetLightEnable(Index, pEnable)); +} + +HRESULT TraceDirect3DDevice9::SetClipPlane(DWORD Index, CONST float* pPlane) { + return (m_pIDirect3DDevice9->SetClipPlane(Index, pPlane)); +} + +HRESULT TraceDirect3DDevice9::GetClipPlane(DWORD Index, float* pPlane) { + return (m_pIDirect3DDevice9->GetClipPlane(Index, pPlane)); +} + +HRESULT TraceDirect3DDevice9::SetRenderState(D3DRENDERSTATETYPE State, DWORD Value) { + return (m_pIDirect3DDevice9->SetRenderState(State, Value)); +} + +HRESULT TraceDirect3DDevice9::GetRenderState(D3DRENDERSTATETYPE State, DWORD* pValue) { + return (m_pIDirect3DDevice9->GetRenderState(State, pValue)); +} + +HRESULT TraceDirect3DDevice9::CreateStateBlock(D3DSTATEBLOCKTYPE Type, IDirect3DStateBlock9** ppSB) { + return (m_pIDirect3DDevice9->CreateStateBlock(Type, ppSB)); +} + +HRESULT TraceDirect3DDevice9::BeginStateBlock(void) { + return (m_pIDirect3DDevice9->BeginStateBlock()); +} + +HRESULT TraceDirect3DDevice9::EndStateBlock(IDirect3DStateBlock9** ppSB) { + return (m_pIDirect3DDevice9->EndStateBlock(ppSB)); +} + +HRESULT TraceDirect3DDevice9::SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus) +{ + return(m_pIDirect3DDevice9->SetClipStatus(pClipStatus)); +} + +HRESULT TraceDirect3DDevice9::GetClipStatus(D3DCLIPSTATUS9* pClipStatus) { + return (m_pIDirect3DDevice9->GetClipStatus(pClipStatus)); +} + +HRESULT TraceDirect3DDevice9::GetTexture(DWORD Stage, IDirect3DBaseTexture9** ppTexture) { + return (m_pIDirect3DDevice9->GetTexture(Stage, ppTexture)); +} + +HRESULT TraceDirect3DDevice9::SetTexture(DWORD Stage, IDirect3DBaseTexture9* pTexture) { + return (m_pIDirect3DDevice9->SetTexture(Stage, pTexture)); +} + +HRESULT TraceDirect3DDevice9::GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD* pValue) { + return (m_pIDirect3DDevice9->GetTextureStageState(Stage, Type, pValue)); +} + +HRESULT TraceDirect3DDevice9::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) { + return (m_pIDirect3DDevice9->SetTextureStageState(Stage, Type, Value)); +} + +HRESULT TraceDirect3DDevice9::GetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD* pValue) { + return (m_pIDirect3DDevice9->GetSamplerState(Sampler, Type, pValue)); +} + +HRESULT TraceDirect3DDevice9::SetSamplerState(DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value) { + return (m_pIDirect3DDevice9->SetSamplerState(Sampler, Type, Value)); +} + +HRESULT TraceDirect3DDevice9::ValidateDevice(DWORD* pNumPasses) { + return (m_pIDirect3DDevice9->ValidateDevice(pNumPasses)); +} + +HRESULT TraceDirect3DDevice9::SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries) +{ + return(m_pIDirect3DDevice9->SetPaletteEntries(PaletteNumber, pEntries)); +} + +HRESULT TraceDirect3DDevice9::GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY* pEntries) { + return (m_pIDirect3DDevice9->GetPaletteEntries(PaletteNumber, pEntries)); +} + +HRESULT TraceDirect3DDevice9::SetCurrentTexturePalette(UINT PaletteNumber) { + return (m_pIDirect3DDevice9->SetCurrentTexturePalette(PaletteNumber)); +} + +HRESULT TraceDirect3DDevice9::GetCurrentTexturePalette(UINT *PaletteNumber) { + return (m_pIDirect3DDevice9->GetCurrentTexturePalette(PaletteNumber)); +} + +HRESULT TraceDirect3DDevice9::SetScissorRect(CONST RECT* pRect) +{ + return(m_pIDirect3DDevice9->SetScissorRect( pRect)); +} + +HRESULT TraceDirect3DDevice9::GetScissorRect(RECT* pRect) { + return (m_pIDirect3DDevice9->GetScissorRect(pRect)); +} + +HRESULT TraceDirect3DDevice9::SetSoftwareVertexProcessing(BOOL bSoftware) { + return (m_pIDirect3DDevice9->SetSoftwareVertexProcessing(bSoftware)); +} + +BOOL TraceDirect3DDevice9::GetSoftwareVertexProcessing(void) { + return (m_pIDirect3DDevice9->GetSoftwareVertexProcessing()); +} + +HRESULT TraceDirect3DDevice9::SetNPatchMode(float nSegments) { + return (m_pIDirect3DDevice9->SetNPatchMode(nSegments)); +} + +float TraceDirect3DDevice9::GetNPatchMode(void) { + return (m_pIDirect3DDevice9->GetNPatchMode()); +} + +HRESULT TraceDirect3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount) { + return (m_pIDirect3DDevice9->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount)); +} + +HRESULT TraceDirect3DDevice9::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount) { + return (m_pIDirect3DDevice9->DrawIndexedPrimitive(PrimitiveType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount)); +} + +HRESULT TraceDirect3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT PrimitiveCount, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + return (m_pIDirect3DDevice9->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride)); +} + +HRESULT TraceDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType, UINT MinVertexIndex, UINT NumVertices, UINT PrimitiveCount, CONST void* pIndexData, D3DFORMAT IndexDataFormat, CONST void* pVertexStreamZeroData, UINT VertexStreamZeroStride) { + return (m_pIDirect3DDevice9->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride)); +} + +HRESULT TraceDirect3DDevice9::ProcessVertices(UINT SrcStartIndex, UINT DestIndex, UINT VertexCount, IDirect3DVertexBuffer9* pDestBuffer, IDirect3DVertexDeclaration9* pVertexDecl, DWORD Flags) { + return (m_pIDirect3DDevice9->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer, pVertexDecl, Flags)); +} + +HRESULT TraceDirect3DDevice9::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl) +{ + return(m_pIDirect3DDevice9->CreateVertexDeclaration( pVertexElements,ppDecl)); +} + +HRESULT TraceDirect3DDevice9::SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl) { + return (m_pIDirect3DDevice9->SetVertexDeclaration(pDecl)); +} + +HRESULT TraceDirect3DDevice9::GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl) { + return (m_pIDirect3DDevice9->GetVertexDeclaration(ppDecl)); +} + +HRESULT TraceDirect3DDevice9::SetFVF(DWORD FVF) { + return (m_pIDirect3DDevice9->SetFVF(FVF)); +} + +HRESULT TraceDirect3DDevice9::GetFVF(DWORD* pFVF) { + return (m_pIDirect3DDevice9->GetFVF(pFVF)); +} + +HRESULT TraceDirect3DDevice9::CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader) +{ + return(m_pIDirect3DDevice9->CreateVertexShader(pFunction,ppShader)); +} + +HRESULT TraceDirect3DDevice9::SetVertexShader(IDirect3DVertexShader9* pShader) { + return (m_pIDirect3DDevice9->SetVertexShader(pShader)); +} + +HRESULT TraceDirect3DDevice9::GetVertexShader(IDirect3DVertexShader9** ppShader) { + return (m_pIDirect3DDevice9->GetVertexShader(ppShader)); +} + +HRESULT TraceDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister, CONST float* pConstantData, UINT Vector4fCount) { + return (m_pIDirect3DDevice9->SetVertexShaderConstantF(StartRegister, pConstantData, Vector4fCount)); +} + +HRESULT TraceDirect3DDevice9::GetVertexShaderConstantF(UINT StartRegister, float* pConstantData, UINT Vector4fCount) { + return (m_pIDirect3DDevice9->GetVertexShaderConstantF(StartRegister, pConstantData, Vector4fCount)); +} + +HRESULT TraceDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister, CONST int* pConstantData, UINT Vector4iCount) { + return (m_pIDirect3DDevice9->SetVertexShaderConstantI(StartRegister, pConstantData, Vector4iCount)); +} + +HRESULT TraceDirect3DDevice9::GetVertexShaderConstantI(UINT StartRegister, int* pConstantData, UINT Vector4iCount) { + return (m_pIDirect3DDevice9->GetVertexShaderConstantI(StartRegister, pConstantData, Vector4iCount)); +} + +HRESULT TraceDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount) +{ + return(m_pIDirect3DDevice9->SetVertexShaderConstantB(StartRegister,pConstantData,BoolCount)); +} + +HRESULT TraceDirect3DDevice9::GetVertexShaderConstantB(UINT StartRegister, BOOL* pConstantData, UINT BoolCount) { + return (m_pIDirect3DDevice9->GetVertexShaderConstantB(StartRegister, pConstantData, BoolCount)); +} + +HRESULT TraceDirect3DDevice9::SetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer9* pStreamData, UINT OffsetInBytes, UINT Stride) { + return (m_pIDirect3DDevice9->SetStreamSource(StreamNumber, pStreamData, OffsetInBytes, Stride)); +} + +HRESULT TraceDirect3DDevice9::GetStreamSource(UINT StreamNumber, IDirect3DVertexBuffer9** ppStreamData, UINT* OffsetInBytes, UINT* pStride) { + return (m_pIDirect3DDevice9->GetStreamSource(StreamNumber, ppStreamData, OffsetInBytes, pStride)); +} + +HRESULT TraceDirect3DDevice9::SetStreamSourceFreq(UINT StreamNumber, UINT Divider) { + return (m_pIDirect3DDevice9->SetStreamSourceFreq(StreamNumber, Divider)); +} + +HRESULT TraceDirect3DDevice9::GetStreamSourceFreq(UINT StreamNumber, UINT* Divider) { + return (m_pIDirect3DDevice9->GetStreamSourceFreq(StreamNumber, Divider)); +} + +HRESULT TraceDirect3DDevice9::SetIndices(IDirect3DIndexBuffer9* pIndexData) { + return (m_pIDirect3DDevice9->SetIndices(pIndexData)); +} + +HRESULT TraceDirect3DDevice9::GetIndices(IDirect3DIndexBuffer9** ppIndexData) { + return (m_pIDirect3DDevice9->GetIndices(ppIndexData)); +} + +HRESULT TraceDirect3DDevice9::CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader) +{ + return(m_pIDirect3DDevice9->CreatePixelShader(pFunction,ppShader)); +} + +HRESULT TraceDirect3DDevice9::SetPixelShader(IDirect3DPixelShader9* pShader) { + return (m_pIDirect3DDevice9->SetPixelShader(pShader)); +} + +HRESULT TraceDirect3DDevice9::GetPixelShader(IDirect3DPixelShader9** ppShader) { + return (m_pIDirect3DDevice9->GetPixelShader(ppShader)); +} + +HRESULT TraceDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister, CONST float* pConstantData, UINT Vector4fCount) { + return (m_pIDirect3DDevice9->SetPixelShaderConstantF(StartRegister, pConstantData, Vector4fCount)); +} + +HRESULT TraceDirect3DDevice9::GetPixelShaderConstantF(UINT StartRegister, float* pConstantData, UINT Vector4fCount) { + return (m_pIDirect3DDevice9->GetPixelShaderConstantF(StartRegister, pConstantData, Vector4fCount)); +} + +HRESULT TraceDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister, CONST int* pConstantData, UINT Vector4iCount) { + return (m_pIDirect3DDevice9->SetPixelShaderConstantI(StartRegister, pConstantData, Vector4iCount)); +} + +HRESULT TraceDirect3DDevice9::GetPixelShaderConstantI(UINT StartRegister, int* pConstantData, UINT Vector4iCount) { + return (m_pIDirect3DDevice9->GetPixelShaderConstantI(StartRegister, pConstantData, Vector4iCount)); +} + +HRESULT TraceDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount) +{ + return(m_pIDirect3DDevice9->SetPixelShaderConstantB(StartRegister,pConstantData,BoolCount)); +} + +HRESULT TraceDirect3DDevice9::GetPixelShaderConstantB(UINT StartRegister, BOOL* pConstantData, UINT BoolCount) { + return (m_pIDirect3DDevice9->GetPixelShaderConstantB(StartRegister, pConstantData, BoolCount)); +} + +HRESULT TraceDirect3DDevice9::DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) +{ + return(m_pIDirect3DDevice9->DrawRectPatch(Handle,pNumSegs, pRectPatchInfo)); +} + +HRESULT TraceDirect3DDevice9::DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) +{ + return(m_pIDirect3DDevice9->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo)); +} + +HRESULT TraceDirect3DDevice9::DeletePatch(UINT Handle) { + return (m_pIDirect3DDevice9->DeletePatch(Handle)); +} + +HRESULT TraceDirect3DDevice9::CreateQuery(D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery) { + return (m_pIDirect3DDevice9->CreateQuery(Type, ppQuery)); +} + +// This is our test function +void TraceDirect3DDevice9::ShowWeAreHere(void) { + D3DRECT rec = { 1, 1, 50, 50 }; + m_pIDirect3DDevice9->Clear(1, &rec, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255, 255, 255, 0), 0, 0); +} + diff --git a/d3d9/idirect3d_device9.hpp b/d3d9/idirect3d_device9.hpp new file mode 100644 index 0000000..f17f0e3 --- /dev/null +++ b/d3d9/idirect3d_device9.hpp @@ -0,0 +1,135 @@ +#pragma once + +class TraceDirect3DDevice9: public IDirect3DDevice9 { +public: + TraceDirect3DDevice9(IDirect3DDevice9* pOriginal); + virtual ~TraceDirect3DDevice9(void); + + // START: The original DX9 function definitions + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj); + ULONG __stdcall AddRef(void); + ULONG __stdcall Release(void); + HRESULT __stdcall TestCooperativeLevel(void); + UINT __stdcall GetAvailableTextureMem(void); + HRESULT __stdcall EvictManagedResources(void); + HRESULT __stdcall GetDirect3D(IDirect3D9** ppD3D9); + HRESULT __stdcall GetDeviceCaps(D3DCAPS9* pCaps); + HRESULT __stdcall GetDisplayMode(UINT iSwapChain, D3DDISPLAYMODE* pMode); + HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters); + HRESULT __stdcall SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9* pCursorBitmap); + void __stdcall SetCursorPosition(int X, int Y, DWORD Flags); + BOOL __stdcall ShowCursor(BOOL bShow); + HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters, IDirect3DSwapChain9** pSwapChain); + HRESULT __stdcall GetSwapChain(UINT iSwapChain, IDirect3DSwapChain9** pSwapChain); + UINT __stdcall GetNumberOfSwapChains(void); + HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters); + HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion); + HRESULT __stdcall GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer); + HRESULT __stdcall GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus); + HRESULT __stdcall SetDialogBoxMode(BOOL bEnableDialogs); + void __stdcall SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp); + void __stdcall GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp); + HRESULT __stdcall CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle); + HRESULT __stdcall CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle); + HRESULT __stdcall CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle); + HRESULT __stdcall CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle); + HRESULT __stdcall CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle); + HRESULT __stdcall CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle); + HRESULT __stdcall CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle); + HRESULT __stdcall UpdateSurface(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint); + HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture9* pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture); + HRESULT __stdcall GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface); + HRESULT __stdcall GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface); + HRESULT __stdcall StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter); + HRESULT __stdcall ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color); + HRESULT __stdcall CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle); + HRESULT __stdcall SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget); + HRESULT __stdcall GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget); + HRESULT __stdcall SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil); + HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface); + HRESULT __stdcall BeginScene(void); + HRESULT __stdcall EndScene(void); + HRESULT __stdcall Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil); + HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix); + HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix); + HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix); + HRESULT __stdcall SetViewport(CONST D3DVIEWPORT9* pViewport); + HRESULT __stdcall GetViewport(D3DVIEWPORT9* pViewport); + HRESULT __stdcall SetMaterial(CONST D3DMATERIAL9* pMaterial); + HRESULT __stdcall GetMaterial(D3DMATERIAL9* pMaterial); + HRESULT __stdcall SetLight(DWORD Index,CONST D3DLIGHT9* pLight); + HRESULT __stdcall GetLight(DWORD Index,D3DLIGHT9* pLight); + HRESULT __stdcall LightEnable(DWORD Index,BOOL Enable); + HRESULT __stdcall GetLightEnable(DWORD Index,BOOL* pEnable); + HRESULT __stdcall SetClipPlane(DWORD Index,CONST float* pPlane); + HRESULT __stdcall GetClipPlane(DWORD Index,float* pPlane); + HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State,DWORD Value); + HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue); + HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9** ppSB); + HRESULT __stdcall BeginStateBlock(void); + HRESULT __stdcall EndStateBlock(IDirect3DStateBlock9** ppSB); + HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus); + HRESULT __stdcall GetClipStatus(D3DCLIPSTATUS9* pClipStatus); + HRESULT __stdcall GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture); + HRESULT __stdcall SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture); + HRESULT __stdcall GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue); + HRESULT __stdcall SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value); + HRESULT __stdcall GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue); + HRESULT __stdcall SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value); + HRESULT __stdcall ValidateDevice(DWORD* pNumPasses); + HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries); + HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries); + HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber); + HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber); + HRESULT __stdcall SetScissorRect(CONST RECT* pRect); + HRESULT __stdcall GetScissorRect( RECT* pRect); + HRESULT __stdcall SetSoftwareVertexProcessing(BOOL bSoftware); + BOOL __stdcall GetSoftwareVertexProcessing(void); + HRESULT __stdcall SetNPatchMode(float nSegments); + float __stdcall GetNPatchMode(void); + HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount); + HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount); + HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride); + HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride); + HRESULT __stdcall ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags); + HRESULT __stdcall CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl); + HRESULT __stdcall SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl); + HRESULT __stdcall GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl); + HRESULT __stdcall SetFVF(DWORD FVF); + HRESULT __stdcall GetFVF(DWORD* pFVF); + HRESULT __stdcall CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader); + HRESULT __stdcall SetVertexShader(IDirect3DVertexShader9* pShader); + HRESULT __stdcall GetVertexShader(IDirect3DVertexShader9** ppShader); + HRESULT __stdcall SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount); + HRESULT __stdcall GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount); + HRESULT __stdcall SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount); + HRESULT __stdcall GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount); + HRESULT __stdcall SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount); + HRESULT __stdcall GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount); + HRESULT __stdcall SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride); + HRESULT __stdcall GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride); + HRESULT __stdcall SetStreamSourceFreq(UINT StreamNumber,UINT Divider); + HRESULT __stdcall GetStreamSourceFreq(UINT StreamNumber,UINT* Divider); + HRESULT __stdcall SetIndices(IDirect3DIndexBuffer9* pIndexData); + HRESULT __stdcall GetIndices(IDirect3DIndexBuffer9** ppIndexData); + HRESULT __stdcall CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader); + HRESULT __stdcall SetPixelShader(IDirect3DPixelShader9* pShader); + HRESULT __stdcall GetPixelShader(IDirect3DPixelShader9** ppShader); + HRESULT __stdcall SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount); + HRESULT __stdcall GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount); + HRESULT __stdcall SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount); + HRESULT __stdcall GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount); + HRESULT __stdcall SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount); + HRESULT __stdcall GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount); + HRESULT __stdcall DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo); + HRESULT __stdcall DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo); + HRESULT __stdcall DeletePatch(UINT Handle); + HRESULT __stdcall CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery); + // END: The original DX9 function definitions + +private: + IDirect3DDevice9 *m_pIDirect3DDevice9; + + // This is our test function + void ShowWeAreHere(void); +}; diff --git a/d3d9/idirect3d_swapchain9.cpp b/d3d9/idirect3d_swapchain9.cpp new file mode 100644 index 0000000..8e814c9 --- /dev/null +++ b/d3d9/idirect3d_swapchain9.cpp @@ -0,0 +1,96 @@ +#include "StdAfx.h" + +TraceDirect3DSwapChain9::TraceDirect3DSwapChain9(IDirect3DSwapChain9* pOriginal, IDirect3DDevice9* pDevice) { + m_pIDirect3DSwapChain9 = pOriginal; // store the pointer to original object + m_pIDirect3DDevice9 = pDevice; +} + +TraceDirect3DSwapChain9::~TraceDirect3DSwapChain9(void) { + m_pIDirect3DSwapChain9 = NULL; +} + +HRESULT TraceDirect3DSwapChain9::QueryInterface(REFIID riid, void** ppvObj) { + // check if original dll can provide interface. then send *our* address + *ppvObj = NULL; + + HRESULT hRes = m_pIDirect3DSwapChain9->QueryInterface(riid, ppvObj); + + if (hRes == NOERROR) { + *ppvObj = this; + } + + return hRes; +} + +ULONG TraceDirect3DSwapChain9::AddRef(void) { + return (m_pIDirect3DSwapChain9->AddRef()); +} + +ULONG TraceDirect3DSwapChain9::Release(void) { + // ATTENTION: This is a booby-trap ! Watch out ! + // If we create our own sprites, surfaces, etc. (thus increasing the ref counter + // by external action), we need to delete that objects before calling the original + // Release function + + // global var + extern TraceDirect3DSwapChain9* gl_pmyIDirect3DSwapChain9; + + // release/delete own objects + // ..... + + // Calling original function now + ULONG count = m_pIDirect3DSwapChain9->Release(); + + if (count == 0) { + // now, the Original Object has deleted itself, so do we here + gl_pmyIDirect3DSwapChain9 = NULL; + delete (this); // destructor will be called automatically + } + + return (count); +} + +HRESULT TraceDirect3DSwapChain9::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion,DWORD dwFlags) +{ + // Some games use this one for presenting. They ignore the Device's present routine + + // we may want to draw own things here before flipping surfaces + // ... draw own stuff ... + this->ShowWeAreHere(); + + // call original routine + HRESULT hres = m_pIDirect3DSwapChain9->Present(pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion,dwFlags); + + return (hres); +} + +HRESULT TraceDirect3DSwapChain9::GetFrontBufferData(IDirect3DSurface9* pDestSurface) { + return (m_pIDirect3DSwapChain9->GetFrontBufferData(pDestSurface)); +} + +HRESULT TraceDirect3DSwapChain9::GetBackBuffer(UINT iBackBuffer, D3DBACKBUFFER_TYPE Type, IDirect3DSurface9** ppBackBuffer) { + return (m_pIDirect3DSwapChain9->GetBackBuffer(iBackBuffer, Type, ppBackBuffer)); +} + +HRESULT TraceDirect3DSwapChain9::GetRasterStatus(D3DRASTER_STATUS* pRasterStatus) { + return (m_pIDirect3DSwapChain9->GetRasterStatus(pRasterStatus)); +} + +HRESULT TraceDirect3DSwapChain9::GetDisplayMode(D3DDISPLAYMODE* pMode) { + return (m_pIDirect3DSwapChain9->GetDisplayMode(pMode)); +} + +HRESULT TraceDirect3DSwapChain9::GetDevice(IDirect3DDevice9** ppDevice) { + return (m_pIDirect3DSwapChain9->GetDevice(ppDevice)); +} + +HRESULT TraceDirect3DSwapChain9::GetPresentParameters(D3DPRESENT_PARAMETERS* pPresentationParameters) { + return (m_pIDirect3DSwapChain9->GetPresentParameters(pPresentationParameters)); +} + +// This is our test function +void TraceDirect3DSwapChain9::ShowWeAreHere(void) { + D3DRECT rec = { 100, 1, 150, 50 }; + m_pIDirect3DDevice9->Clear(1, &rec, D3DCLEAR_TARGET, D3DCOLOR_ARGB(255, 255, 255, 0), 0, 0); +} + diff --git a/d3d9/idirect3d_swapchain9.hpp b/d3d9/idirect3d_swapchain9.hpp new file mode 100644 index 0000000..36d08b2 --- /dev/null +++ b/d3d9/idirect3d_swapchain9.hpp @@ -0,0 +1,27 @@ +#pragma once + +class TraceDirect3DSwapChain9: public IDirect3DSwapChain9 { +public: + TraceDirect3DSwapChain9(IDirect3DSwapChain9* pOriginal, IDirect3DDevice9* pDevice); + virtual ~TraceDirect3DSwapChain9(void); + + // START: The original DX9 function definitions + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj); + ULONG __stdcall AddRef(void); + ULONG __stdcall Release(void); + HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion,DWORD dwFlags); + HRESULT __stdcall GetFrontBufferData(IDirect3DSurface9* pDestSurface); + HRESULT __stdcall GetBackBuffer(UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer); + HRESULT __stdcall GetRasterStatus(D3DRASTER_STATUS* pRasterStatus); + HRESULT __stdcall GetDisplayMode(D3DDISPLAYMODE* pMode); + HRESULT __stdcall GetDevice(IDirect3DDevice9** ppDevice); + HRESULT __stdcall GetPresentParameters(D3DPRESENT_PARAMETERS* pPresentationParameters); + // END: The original DX9 function definitions + +private: + IDirect3DSwapChain9 *m_pIDirect3DSwapChain9; + IDirect3DDevice9 *m_pIDirect3DDevice9; + + // This is our test function + void ShowWeAreHere(void); +}; diff --git a/d3d9/stdafx.h b/d3d9/stdafx.h new file mode 100644 index 0000000..197d021 --- /dev/null +++ b/d3d9/stdafx.h @@ -0,0 +1,12 @@ +// stdafx.h +#pragma once + +#define WIN32_LEAN_AND_MEAN +#include +#include + +#include + +#include "idirect3d9.hpp" +#include "idirect3d_device9.hpp" +#include "idirect3d_swapchain9.hpp" -- 2.45.2