1HEADmaster

1 files changed, 1289 insertions, 0 deletions

diff --git a/materialsystem/shaderapidx9/dx9hook.h b/materialsystem/shaderapidx9/dx9hook.h
new file mode 100644
index 0000000..a117f3e
--- /dev/null
+++ b/materialsystem/shaderapidx9/dx9hook.h
@@ -0,0 +1,1289 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+/* 
+TODO: add option to null out drawprim calls.
+ 
+Also maybe hook the PIX_ENABLE stuff to Telemetry
+ 
+		In imaterialsystem.h:
+		#define PIX_ENABLE 1                   // set this to 1 and build engine/studiorender to enable pix events in the engine
+
+		And in shaderapidx8.h:
+    	#define PIX_ENABLE 1                   // set this to 1 and build engine/studiorender to enable pix events in the engine
+ 
+Might be interesting to make it so dx9hook.h paid attention to the PIX_ENABLE names
+	and allowed you to filter drawprim calls based on those?
+*/
+
+#ifndef _DX9HOOK_H_
+#define _DX9HOOK_H_
+
+#if D3D_BATCH_PERF_ANALYSIS
+	#include "../../thirdparty/miniz/miniz.c"
+	#include "../../thirdparty/miniz/simple_bitmap.h"
+
+	extern ConVar d3d_batch_vis, d3d_batch_vis_abs_scale, d3d_batch_vis_y_scale, d3d_present_vis_abs_scale;
+	extern uint64 g_nTotalD3DCalls, g_nTotalD3DCycles;
+
+	class CD3DCallTimer
+	{
+	public:
+		inline CD3DCallTimer() { g_nTotalD3DCalls++; g_nTotalD3DCycles -= tmFastTime(); }
+		inline ~CD3DCallTimer() {  g_nTotalD3DCycles += tmFastTime(); }
+	};
+	
+	#define D3D_BATCH_PERF(...) __VA_ARGS__
+#else
+	#define D3D_BATCH_PERF(...)
+#endif
+
+#if D3D_BATCH_PERF_ANALYSIS
+	#define XXX \
+		tmZone( TELEMETRY_LEVEL3, TMZF_NONE, "D3D9: %s", __FUNCTION__ ); \
+		CD3DCallTimer scopedCallTimer;
+#else
+	#define XXX																													\
+		if( ThreadInMainThread() )  																							\
+		{   																													\
+			tmMessage( TELEMETRY_LEVEL0, TMMF_ICON_NOTE | TMMF_SEVERITY_WARNING, "(source/d3d)%s", __FUNCTION__ );				\
+			tmZoneFiltered( TELEMETRY_LEVEL0, 50, TMZF_NONE, "%s", __FUNCTION__ );												\
+		}
+#endif
+
+// Hooks for routines which return values.
+#define _DOCALL0( _member )				( m_Data.pHWObj->_member )()
+#define _DOCALL( _member, ... )			( m_Data.pHWObj->_member )( __VA_ARGS__ )
+// And hooks for routines which return squatola.
+#define _DOCALL0_NORET( _member )		( m_Data.pHWObj->_member )()
+#define _DOCALL_NORET( _member, ... )	( m_Data.pHWObj->_member )( __VA_ARGS__)
+
+#define DEF_HOOKCLASSES( X )												\
+    template<> class CDx9HookBase< struct I ## X >							\
+    {                                                   					\
+    public:                                             					\
+        typedef I ## X 					_D3DINTERFACE;                		\
+        typedef class C ## X ## Hook 	_HOOKCLASS;                			\
+																			\
+	public:  																\
+		CDx9HookBase() { memset( &m_Data, 0, sizeof( m_Data ) ); }  		\
+		virtual ~CDx9HookBase() {}  										\
+																			\
+	public: 																\
+		struct DATA 														\
+		{   																\
+			class CDirect3DDevice9Hook *pDevice;   							\
+			_D3DINTERFACE	*pHWObj;    									\
+		};  																\
+																			\
+		DATA m_Data;														\
+    }
+
+template < class T > class CDx9HookBase;
+DEF_HOOKCLASSES( Direct3DVertexDeclaration9 );
+DEF_HOOKCLASSES( Direct3DPixelShader9 );
+DEF_HOOKCLASSES( Direct3DVertexShader9 );
+DEF_HOOKCLASSES( Direct3DVertexBuffer9 );
+DEF_HOOKCLASSES( Direct3DIndexBuffer9 );
+DEF_HOOKCLASSES( Direct3DQuery9 );
+DEF_HOOKCLASSES( Direct3DStateBlock9 );
+DEF_HOOKCLASSES( Direct3DSurface9 );
+DEF_HOOKCLASSES( Direct3DBaseTexture9 );
+DEF_HOOKCLASSES( Direct3DTexture9 );
+DEF_HOOKCLASSES( Direct3DCubeTexture9 );
+DEF_HOOKCLASSES( Direct3DVolume9 );
+DEF_HOOKCLASSES( Direct3DVolumeTexture9 );
+DEF_HOOKCLASSES( Direct3DSwapChain9 );
+DEF_HOOKCLASSES( Direct3D9 );
+DEF_HOOKCLASSES( Direct3DDevice9 );
+
+template < class _D3DINTERFACE > HRESULT AllocOverride( HRESULT *hr, class CDirect3DDevice9Hook *pDevice, _D3DINTERFACE **ppHWObj )
+{
+    if( SUCCEEDED(*hr) && ppHWObj && *ppHWObj )
+    {
+        CDx9HookBase< _D3DINTERFACE >::_HOOKCLASS *pClass = new CDx9HookBase< _D3DINTERFACE >::_HOOKCLASS;
+
+        if(!pClass)
+        {
+            ( *ppHWObj )->Release();
+            *hr = E_OUTOFMEMORY;
+            return NULL;
+        }
+        pClass->m_Data.pDevice = pDevice;
+		pClass->m_Data.pHWObj = *ppHWObj;
+		*ppHWObj = pClass;
+        return *hr;
+    }
+
+    return *hr;
+}
+
+template <class _D3DINTERFACE> _D3DINTERFACE *GetHWPtr( _D3DINTERFACE *pD3DInterface )
+{
+	if( pD3DInterface )
+	{
+        CDx9HookBase< _D3DINTERFACE >::_HOOKCLASS *pClass = ( CDx9HookBase< _D3DINTERFACE >::_HOOKCLASS * )pD3DInterface;
+		return pClass->m_Data.pHWObj;
+	}
+	return NULL;
+}
+
+template <class _D3DINTERFACE> CDirect3DDevice9Hook *GetHookDevice( _D3DINTERFACE *pD3DInterface )
+{
+	if( pD3DInterface )
+	{
+        CDx9HookBase< _D3DINTERFACE >::_HOOKCLASS *pClass = ( CDx9HookBase< _D3DINTERFACE >::_HOOKCLASS * )pD3DInterface;
+		return pClass->m_Data.pDevice;
+	}
+	return NULL;
+}
+
+//$ TODO: if(riid == IID_IDirect3DDevice9Ex, IID_IDirect3DDevice9, etc.
+#define IMPL_QUERYINTERFACE()                                                   \
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void** ppvObj)                 \
+	{																			\
+		__debugbreak();															\
+		XXX; return _DOCALL(QueryInterface, riid, ppvObj);						\
+	}
+
+#define IMPL_IUNKOWN()                                                          \
+    IMPL_QUERYINTERFACE();                                                      \
+    STDMETHOD_(ULONG,AddRef)(THIS)                                              \
+        { XXX; return _DOCALL0(AddRef); }										\
+    STDMETHOD_(ULONG,Release)(THIS)                                             \
+	{																			\
+		XXX;																	\
+		ULONG retval = _DOCALL0(Release);   									\
+		if(retval == 0) 														\
+			delete this;														\
+		return retval;  														\
+	}
+
+#define IMPL_GETDEVICE()                                                        \
+    STDMETHOD(GetDevice)(THIS_ IDirect3DDevice9** ppDevice)                     \
+	{																			\
+		XXX;																	\
+		HRESULT hr = _DOCALL( GetDevice, ppDevice );							\
+		return AllocOverride( &hr, m_Data.pDevice, ppDevice );					\
+	}
+
+#define IMPL_SETPRIVATEDATA()                                                                       \
+    STDMETHOD(SetPrivateData)(THIS_ REFGUID refguid,CONST void* pData,DWORD SizeOfData,DWORD Flags) \
+        { XXX; return _DOCALL(SetPrivateData, refguid, pData, SizeOfData, Flags); }
+
+#define IMPL_GETPRIVATEDATA()                                                           \
+    STDMETHOD(GetPrivateData)(THIS_ REFGUID refguid,void* pData,DWORD* pSizeOfData)     \
+        { XXX; return _DOCALL(GetPrivateData, refguid, pData, pSizeOfData); }
+
+#define IMPL_FREEPRIVATEDATA()                                                  \
+    STDMETHOD(FreePrivateData)(THIS_ REFGUID refguid)                           \
+        { XXX; return _DOCALL(FreePrivateData, refguid); }
+
+#define IMPL_IDIRECT3DRESOURCE9()                                               \
+    IMPL_GETDEVICE();                                                           \
+    IMPL_SETPRIVATEDATA();                                                      \
+    IMPL_GETPRIVATEDATA();                                                      \
+    IMPL_FREEPRIVATEDATA();                                                     \
+    STDMETHOD_(DWORD, SetPriority)(THIS_ DWORD PriorityNew)                     \
+		{ XXX; return _DOCALL(SetPriority, PriorityNew); }                      \
+    STDMETHOD_(DWORD, GetPriority)(THIS)                                        \
+        { XXX; return _DOCALL0(GetPriority); }                                  \
+    STDMETHOD_(void, PreLoad)(THIS)                                             \
+        { XXX; _DOCALL0_NORET(PreLoad); }                                     	\
+    STDMETHOD_(D3DRESOURCETYPE, GetType)(THIS)                                  \
+        { XXX; return _DOCALL0(GetType); }
+
+class CDirect3DSwapChain9Hook : public CDx9HookBase<IDirect3DSwapChain9>, public IDirect3DSwapChain9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DSwapChain9 methods ***/
+    STDMETHOD(Present)(THIS_ CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion,DWORD dwFlags)
+		{ XXX; return _DOCALL(Present, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion, dwFlags); }
+
+    STDMETHOD(GetFrontBufferData)(THIS_ IDirect3DSurface9* pDestSurface)
+	{
+		XXX; return _DOCALL(GetFrontBufferData, GetHWPtr(pDestSurface));
+	}
+    STDMETHOD(GetBackBuffer)(THIS_ UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetBackBuffer, iBackBuffer, Type, ppBackBuffer);
+		return AllocOverride( &hr, m_Data.pDevice, ppBackBuffer );
+	}
+
+    STDMETHOD(GetRasterStatus)(THIS_ D3DRASTER_STATUS* pRasterStatus)
+        { XXX; return _DOCALL(GetRasterStatus, pRasterStatus); }
+    STDMETHOD(GetDisplayMode)(THIS_ D3DDISPLAYMODE* pMode)
+        { XXX; return _DOCALL(GetDisplayMode, pMode); }
+
+    IMPL_GETDEVICE();
+
+    STDMETHOD(GetPresentParameters)(THIS_ D3DPRESENT_PARAMETERS* pPresentationParameters)
+        { XXX; return _DOCALL(GetPresentParameters, pPresentationParameters); }
+};
+
+class CDirect3DVertexDeclaration9Hook : public CDx9HookBase<IDirect3DVertexDeclaration9>, public IDirect3DVertexDeclaration9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DVertexDeclaration9 methods
+    IMPL_GETDEVICE();
+
+    STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 *pVertElem, UINT* pNumElements)
+        { XXX; return _DOCALL(GetDeclaration, pVertElem, pNumElements); }
+};
+
+class CDirect3DPixelShader9Hook : public CDx9HookBase<IDirect3DPixelShader9>, public IDirect3DPixelShader9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DPixelShader9 methods
+    IMPL_GETDEVICE();
+
+    STDMETHOD(GetFunction)(THIS_ void *pData,UINT* pSizeOfData)
+        { XXX; return _DOCALL(GetFunction, pData, pSizeOfData); }
+};
+
+class CDirect3DVertexShader9Hook : public CDx9HookBase<IDirect3DVertexShader9>, public IDirect3DVertexShader9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DVertexDeclaration9 methods
+    IMPL_GETDEVICE();
+
+    STDMETHOD(GetFunction)(THIS_ void *pData,UINT* pSizeOfData)
+        { XXX; return _DOCALL(GetFunction, pData, pSizeOfData); }
+};
+
+class CDirect3DVertexBuffer9Hook : public CDx9HookBase<IDirect3DVertexBuffer9>, public IDirect3DVertexBuffer9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DResource9 methods
+    IMPL_IDIRECT3DRESOURCE9();
+
+    // IDirect3DVertexBuffer9
+    STDMETHOD(Lock)(THIS_ UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags)
+		{ XXX; return _DOCALL(Lock, OffsetToLock, SizeToLock, ppbData, Flags); }
+    STDMETHOD(Unlock)(THIS)
+		{ XXX; return _DOCALL0(Unlock); }
+
+    STDMETHOD(GetDesc)(THIS_ D3DVERTEXBUFFER_DESC *pDesc)
+        { XXX; return _DOCALL(GetDesc, pDesc); }
+};
+
+class CDirect3DIndexBuffer9Hook : public CDx9HookBase<IDirect3DIndexBuffer9>, public IDirect3DIndexBuffer9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DResource9 methods
+    IMPL_IDIRECT3DRESOURCE9();
+
+    // IDirect3DIndexBuffer9
+    STDMETHOD(Lock)(THIS_ UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags)
+		{ XXX; return _DOCALL(Lock, OffsetToLock, SizeToLock, ppbData, Flags); }
+    STDMETHOD(Unlock)(THIS)
+		{ XXX; return _DOCALL0(Unlock); }
+
+    STDMETHOD(GetDesc)(THIS_ D3DINDEXBUFFER_DESC *pDesc)
+        { XXX; return _DOCALL(GetDesc, pDesc); }
+};
+
+class CDirect3DQuery9Hook : public CDx9HookBase<IDirect3DQuery9>, public IDirect3DQuery9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DQuery9 methods ***/
+    IMPL_GETDEVICE();
+
+    // IDirect3DQuery9
+    STDMETHOD_(D3DQUERYTYPE, GetType)(THIS)
+        { XXX; return _DOCALL0(GetType); }
+    STDMETHOD_(DWORD, GetDataSize)(THIS)
+        { XXX; return _DOCALL0(GetDataSize); }
+    STDMETHOD(Issue)(THIS_ DWORD dwIssueFlags)
+        { XXX; return _DOCALL(Issue, dwIssueFlags); }
+    STDMETHOD(GetData)(THIS_ void* pData,DWORD dwSize,DWORD dwGetDataFlags)
+        { XXX; return _DOCALL(GetData, pData, dwSize, dwGetDataFlags); }
+};
+
+class CDirect3DStateBlock9Hook : public CDx9HookBase<IDirect3DStateBlock9>, public IDirect3DStateBlock9
+{
+public:
+    CDirect3DStateBlock9Hook() {}
+    virtual ~CDirect3DStateBlock9Hook() {}
+
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DStateBlock9 methods
+    IMPL_GETDEVICE();
+
+    STDMETHOD(Capture)(THIS)
+		{ XXX; return _DOCALL0(Capture); }
+    STDMETHOD(Apply)(THIS)
+		{ XXX; return _DOCALL0(Apply); }
+};
+
+class CDirect3DSurface9Hook : public CDx9HookBase<IDirect3DSurface9>, public IDirect3DSurface9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3DResource9 methods
+    IMPL_IDIRECT3DRESOURCE9();
+
+    STDMETHOD(GetContainer)(THIS_ REFIID riid,void** ppContainer)
+	{
+		//$ TODO: do the call, check riid, and wrap the returned ppContainer
+		__debugbreak();
+		XXX; return _DOCALL(GetContainer, riid, ppContainer);
+	}
+    STDMETHOD(GetDesc)(THIS_ D3DSURFACE_DESC *pDesc)
+        { XXX; return _DOCALL(GetDesc, pDesc); }
+
+    STDMETHOD(LockRect)(THIS_ D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags)
+		{ XXX; return _DOCALL(LockRect, pLockedRect, pRect, Flags); }
+    STDMETHOD(UnlockRect)(THIS)
+		{ XXX; return _DOCALL0(UnlockRect); }
+
+    STDMETHOD(GetDC)(THIS_ HDC *phdc)
+        { XXX; return _DOCALL(GetDC, phdc); }
+    STDMETHOD(ReleaseDC)(THIS_ HDC hdc)
+        { XXX; return _DOCALL(ReleaseDC, hdc); }
+};
+
+class CDirect3DBaseTexture9Hook : public CDx9HookBase<IDirect3DBaseTexture9>, public IDirect3DBaseTexture9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DBaseTexture9 methods ***/
+    IMPL_IDIRECT3DRESOURCE9();
+
+	STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew)
+		{ XXX; return _DOCALL(SetLOD, LODNew); }
+	STDMETHOD_(DWORD, GetLOD)(THIS)
+		{ XXX; return _DOCALL0(GetLOD); }
+	STDMETHOD_(DWORD, GetLevelCount)(THIS)
+		{ XXX; return _DOCALL0(GetLevelCount); }
+	STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType)
+		{ XXX; return _DOCALL(SetAutoGenFilterType, FilterType); }
+	STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS)
+		{ XXX; return _DOCALL0(GetAutoGenFilterType); }
+	STDMETHOD_(void, GenerateMipSubLevels)(THIS)
+		{ XXX; return _DOCALL0(GenerateMipSubLevels); }
+};
+
+class CDirect3DTexture9Hook : public CDx9HookBase<IDirect3DTexture9>, public IDirect3DTexture9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DBaseTexture9 methods ***/
+    IMPL_IDIRECT3DRESOURCE9();
+
+    STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew)
+		{ XXX; return _DOCALL(SetLOD, LODNew); }
+    STDMETHOD_(DWORD, GetLOD)(THIS)
+        { XXX; return _DOCALL0(GetLOD); }
+    STDMETHOD_(DWORD, GetLevelCount)(THIS)
+        { XXX; return _DOCALL0(GetLevelCount); }
+    STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType)
+		{ XXX; return _DOCALL(SetAutoGenFilterType, FilterType); }
+    STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS)
+        { XXX; return _DOCALL0(GetAutoGenFilterType); }
+
+    STDMETHOD_(void, GenerateMipSubLevels)(THIS)
+		{ XXX; return _DOCALL0(GenerateMipSubLevels); }
+
+    STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DSURFACE_DESC *pDesc)
+        { XXX; return _DOCALL(GetLevelDesc, Level, pDesc); }
+
+    STDMETHOD(GetSurfaceLevel)(THIS_ UINT Level,IDirect3DSurface9** ppSurfaceLevel)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetSurfaceLevel, Level, ppSurfaceLevel);
+		return AllocOverride( &hr, m_Data.pDevice, ppSurfaceLevel );
+	}
+    STDMETHOD(LockRect)(THIS_ UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags)
+		{ XXX; return _DOCALL(LockRect, Level, pLockedRect, pRect, Flags); }
+    STDMETHOD(UnlockRect)(THIS_ UINT Level)
+		{ XXX; return _DOCALL(UnlockRect, Level); }
+
+    STDMETHOD(AddDirtyRect)(THIS_ CONST RECT* pDirtyRect)
+        { XXX; return _DOCALL(AddDirtyRect, pDirtyRect); }
+};
+
+class CDirect3DCubeTexture9Hook : public CDx9HookBase<IDirect3DCubeTexture9>, public IDirect3DCubeTexture9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DBaseTexture9 methods ***/
+    IMPL_IDIRECT3DRESOURCE9();
+
+    STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew)
+		{ XXX; return _DOCALL(SetLOD, LODNew); }
+    STDMETHOD_(DWORD, GetLOD)(THIS)
+        { XXX; return _DOCALL0(GetLOD); }
+    STDMETHOD_(DWORD, GetLevelCount)(THIS)
+        { XXX; return _DOCALL0(GetLevelCount); }
+    STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType)
+		{ XXX; return _DOCALL(SetAutoGenFilterType, FilterType); }
+    STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS)
+        { XXX; return _DOCALL0(GetAutoGenFilterType); }
+
+    STDMETHOD_(void, GenerateMipSubLevels)(THIS)
+		{ XXX; return _DOCALL0(GenerateMipSubLevels); }
+
+    STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DSURFACE_DESC *pDesc)
+        { XXX; return _DOCALL(GetLevelDesc, Level, pDesc); }
+
+    STDMETHOD(GetCubeMapSurface)(THIS_ D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetCubeMapSurface, FaceType, Level, ppCubeMapSurface);
+		return AllocOverride(&hr, m_Data.pDevice, ppCubeMapSurface);
+	}
+    STDMETHOD(LockRect)(THIS_ D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags)
+		{ XXX; return _DOCALL(LockRect, FaceType, Level, pLockedRect, pRect, Flags); }
+    STDMETHOD(UnlockRect)(THIS_ D3DCUBEMAP_FACES FaceType,UINT Level)
+		{ XXX; return _DOCALL(UnlockRect, FaceType, Level); }
+
+    STDMETHOD(AddDirtyRect)(THIS_ D3DCUBEMAP_FACES FaceType,CONST RECT* pDirtyRect)
+        { XXX; return _DOCALL(AddDirtyRect, FaceType, pDirtyRect); }
+};
+
+class CDirect3DVolume9Hook : public CDx9HookBase<IDirect3DVolume9>, public IDirect3DVolume9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DVolume9 methods ***/
+    IMPL_GETDEVICE();
+
+    IMPL_SETPRIVATEDATA();
+    IMPL_GETPRIVATEDATA();
+    IMPL_FREEPRIVATEDATA()
+
+    STDMETHOD(GetContainer)(THIS_ REFIID riid,void** ppContainer)
+	{
+		//$ TODO: do the call, check riid, and wrap the returned ppContainer
+		__debugbreak();
+		XXX; return _DOCALL(GetContainer, riid, ppContainer);
+	}
+
+    STDMETHOD(GetDesc)(THIS_ D3DVOLUME_DESC *pDesc)
+        { XXX; return _DOCALL(GetDesc, pDesc); }
+
+    STDMETHOD(LockBox)(THIS_ D3DLOCKED_BOX * pLockedVolume,CONST D3DBOX* pBox,DWORD Flags)
+		{ XXX; return _DOCALL(LockBox, pLockedVolume, pBox, Flags); }
+    STDMETHOD(UnlockBox)(THIS)
+		{ XXX; return _DOCALL0(UnlockBox); }
+};
+
+class CDirect3DVolumeTexture9Hook : public CDx9HookBase<IDirect3DVolumeTexture9>, public IDirect3DVolumeTexture9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    /*** IDirect3DBaseTexture9 methods ***/
+    IMPL_IDIRECT3DRESOURCE9();
+
+    STDMETHOD_(DWORD, SetLOD)(THIS_ DWORD LODNew)
+		{ XXX; return _DOCALL(SetLOD, LODNew); }
+    STDMETHOD_(DWORD, GetLOD)(THIS)
+        { XXX; return _DOCALL0(GetLOD); }
+    STDMETHOD_(DWORD, GetLevelCount)(THIS)
+        { XXX; return _DOCALL0(GetLevelCount); }
+    STDMETHOD(SetAutoGenFilterType)(THIS_ D3DTEXTUREFILTERTYPE FilterType)
+		{ XXX; return _DOCALL(SetAutoGenFilterType, FilterType); }
+    STDMETHOD_(D3DTEXTUREFILTERTYPE, GetAutoGenFilterType)(THIS)
+        { XXX; return _DOCALL0(GetAutoGenFilterType); }
+
+    STDMETHOD_(void, GenerateMipSubLevels)(THIS)
+		{ XXX; return _DOCALL0(GenerateMipSubLevels); }
+
+    STDMETHOD(GetLevelDesc)(THIS_ UINT Level,D3DVOLUME_DESC *pDesc)
+        { XXX; return _DOCALL(GetLevelDesc, Level, pDesc); }
+
+    STDMETHOD(GetVolumeLevel)(THIS_ UINT Level,IDirect3DVolume9** ppVolumeLevel)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetVolumeLevel, Level, ppVolumeLevel);
+		return AllocOverride( &hr, m_Data.pDevice, ppVolumeLevel );
+	}
+    STDMETHOD(LockBox)(THIS_ UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags)
+		{ XXX; return _DOCALL(LockBox, Level, pLockedVolume, pBox, Flags); }
+    STDMETHOD(UnlockBox)(THIS_ UINT Level)
+		{ XXX; return _DOCALL(UnlockBox, Level); }
+
+    STDMETHOD(AddDirtyBox)(THIS_ CONST D3DBOX* pDirtyBox)
+        { XXX; return _DOCALL(AddDirtyBox, pDirtyBox); }
+};
+
+class CDirect3DDevice9Hook : public CDx9HookBase<IDirect3DDevice9>, public IDirect3DDevice9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+	CDirect3DDevice9Hook() : CDx9HookBase<IDirect3DDevice9>(), IDirect3DDevice9()
+	{
+		D3D_BATCH_PERF( g_nTotalD3DCycles = 0; g_nTotalD3DCalls = 0; m_batch_state.Clear(); m_nTotalDraws = 0; m_nTotalPrims = 0; m_nTotalD3DCalls = 0; m_flTotalD3DTime = 0; m_nOverallDraws = 0; m_nOverallPrims = 0; m_nOverallD3DCalls = 0; m_flOverallD3DTime = 0; m_nTotalFrames = 0; m_pPrevRenderTarget0 = NULL; )
+	}
+
+    // IDirect3DDevice9 methods
+    STDMETHOD(TestCooperativeLevel)(THIS)
+        { XXX; return _DOCALL0(TestCooperativeLevel); }
+    STDMETHOD_(UINT, GetAvailableTextureMem)(THIS)
+        {  XXX; return _DOCALL0(GetAvailableTextureMem); }
+    STDMETHOD(EvictManagedResources)(THIS)
+        { XXX; return _DOCALL0(EvictManagedResources); }
+    STDMETHOD(GetDirect3D)(THIS_ IDirect3D9** ppD3D9)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetDirect3D, ppD3D9);
+		return AllocOverride(&hr, this, ppD3D9);
+	}
+    STDMETHOD(GetDeviceCaps)(THIS_ D3DCAPS9* pCaps)
+		{ XXX; return _DOCALL(GetDeviceCaps, pCaps); }
+    STDMETHOD(GetDisplayMode)(THIS_ UINT iSwapChain,D3DDISPLAYMODE* pMode)
+        { XXX; return _DOCALL(GetDisplayMode, iSwapChain, pMode); }
+    STDMETHOD(GetCreationParameters)(THIS_ D3DDEVICE_CREATION_PARAMETERS *pParameters)
+        { XXX; return _DOCALL(GetCreationParameters, pParameters); }
+    STDMETHOD(SetCursorProperties)(THIS_ UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9* pCursorBitmap)
+		{ XXX; return _DOCALL(SetCursorProperties, XHotSpot, YHotSpot, GetHWPtr(pCursorBitmap)); }
+    STDMETHOD_(void, SetCursorPosition)(THIS_ int X,int Y,DWORD Flags)
+        { XXX; _DOCALL_NORET(SetCursorPosition, X, Y, Flags); }
+    STDMETHOD_(BOOL, ShowCursor)(THIS_ BOOL bShow)
+        { XXX; return _DOCALL(ShowCursor, bShow); }
+    STDMETHOD(CreateAdditionalSwapChain)(THIS_ D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9** ppSwapChain)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateAdditionalSwapChain, pPresentationParameters, ppSwapChain);
+		return AllocOverride(&hr, this, ppSwapChain);
+	}
+    STDMETHOD(GetSwapChain)(THIS_ UINT iSwapChain,IDirect3DSwapChain9** ppSwapChain)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetSwapChain, iSwapChain, ppSwapChain);
+		return AllocOverride(&hr, this, ppSwapChain);
+	}
+    STDMETHOD_(UINT, GetNumberOfSwapChains)(THIS)
+        { XXX; return _DOCALL0(GetNumberOfSwapChains); }
+    STDMETHOD(Reset)(THIS_ D3DPRESENT_PARAMETERS* pPresentationParameters)
+		{ XXX; return _DOCALL( Reset, pPresentationParameters ); }
+    STDMETHOD(Present)(THIS_ CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
+	{ 
+		HRESULT hres;
+
+#if D3D_BATCH_PERF_ANALYSIS
+		uint64 nStartCycles = g_nTotalD3DCycles;
+
+		CFastTimer tm;
+		tm.Start();
+
+		g_nTotalD3DCalls++;
+#endif
+
+		{
+			XXX; 
+			hres = _DOCALL(Present, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion); 
+		}
+				
+#if D3D_BATCH_PERF_ANALYSIS
+		const uint nFrameIndex = m_nTotalFrames;
+		m_nTotalFrames++;
+
+		if (nFrameIndex >= 5)
+		{
+			double flPresentTime = tm.GetDurationInProgress().GetMillisecondsF();
+			uint64 nEndCycles = g_nTotalD3DCycles;
+
+			double flTotalPresentTime = ( nEndCycles - nStartCycles ) * s_rdtsc_to_ms;
+
+			m_nTotalD3DCalls += g_nTotalD3DCalls;
+			m_flTotalD3DTime += g_nTotalD3DCycles * s_rdtsc_to_ms;
+				
+			static int bPrevBatchVis = -1;
+
+			if ((bPrevBatchVis == 1) && m_batch_vis_bitmap.is_valid())
+			{
+				m_nOverallDraws += m_nTotalDraws;
+				m_nOverallPrims += m_nTotalPrims;
+				m_nOverallD3DCalls += m_nTotalD3DCalls;
+				m_flOverallD3DTime += m_flTotalD3DTime;
+
+				m_batch_vis_bitmap.fill_box(0, m_nBatchVisY, (uint)(.5f + flPresentTime / d3d_present_vis_abs_scale.GetFloat() * m_batch_vis_bitmap.width()), 10, 255, 16, 128);
+				m_batch_vis_bitmap.additive_fill_box(0, m_nBatchVisY, (uint)(.5f + flTotalPresentTime / d3d_present_vis_abs_scale.GetFloat() * m_batch_vis_bitmap.width()), 10, 0, 255, 128);
+				m_nBatchVisY += 10;
+			
+				uint y = MAX( 600, m_nBatchVisY + 20 ), l = 0;
+				m_batch_vis_bitmap.draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Frame: %u, Batches: %u, Prims: %u", nFrameIndex, m_nTotalDraws, m_nTotalPrims );
+				m_batch_vis_bitmap.draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Frame: D3D Calls: %u, D3D Time: %3.3fms", m_nTotalD3DCalls, m_flTotalD3DTime);
+				l++;
+				m_batch_vis_bitmap.draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Overall: Batches: %u, Prims: %u", m_nOverallDraws, m_nOverallPrims );
+				m_batch_vis_bitmap.draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Overall: D3D Calls: %u D3D Time: %4.3fms", m_nOverallD3DCalls, m_flOverallD3DTime );
+
+				size_t png_size = 0;
+				void *pPNG_data = tdefl_write_image_to_png_file_in_memory(m_batch_vis_bitmap.get_ptr(), m_batch_vis_bitmap.width(), m_batch_vis_bitmap.height(), 3, &png_size, true);
+				if (pPNG_data)
+				{
+					char filename[256];
+					V_snprintf(filename, sizeof(filename), "left4dead2/batchvis_%u_%u.png", m_nBatchVisFileIdx, m_nBatchVisFrameIndex);
+					FILE* pFile = fopen(filename, "wb");
+					if (pFile)
+					{
+						fwrite(pPNG_data, png_size, 1, pFile);
+						fclose(pFile);
+					}
+					free(pPNG_data);
+				}
+				m_nBatchVisFrameIndex++;
+				m_nBatchVisY = 0;
+				m_batch_vis_bitmap.cls();
+			}
+
+			if (bPrevBatchVis != (int)d3d_batch_vis.GetBool())
+			{
+				bPrevBatchVis = d3d_batch_vis.GetBool();
+				if (!bPrevBatchVis)
+				{
+					m_batch_vis_bitmap.clear();
+				}
+				else
+				{
+					m_batch_vis_bitmap.init(768, 1024);
+				}
+				m_nBatchVisY = 0;
+				m_nBatchVisFrameIndex = 0;
+				m_nBatchVisFileIdx = (uint)time(NULL); //rand();
+
+				m_nOverallDraws = 0;
+				m_nOverallPrims = 0;
+				m_nOverallD3DCalls = 0;
+				m_flOverallD3DTime = 0;
+			}
+		}
+
+		m_nTotalD3DCalls = 0;
+		m_nTotalPrims = 0;
+		m_flTotalD3DTime = 0;
+		g_nTotalD3DCycles = 0;
+		g_nTotalD3DCalls = 0;
+		m_nTotalDraws = 0;
+#else
+		if ( d3d_batch_vis.GetBool() )
+		{
+			d3d_batch_vis.SetValue( false );
+
+			ConMsg( "Must define D3D_BATCH_PERF_ANALYSIS to use this feature" );
+		}
+#endif
+
+		return hres;
+	}
+
+    STDMETHOD(GetBackBuffer)(THIS_ UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetBackBuffer, iSwapChain, iBackBuffer, Type, ppBackBuffer);
+		return AllocOverride(&hr, this, ppBackBuffer);
+	}
+    STDMETHOD(GetRasterStatus)(THIS_ UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus)
+        { XXX; return _DOCALL(GetRasterStatus, iSwapChain, pRasterStatus); }
+    STDMETHOD(SetDialogBoxMode)(THIS_ BOOL bEnableDialogs)
+        { XXX; return _DOCALL(SetDialogBoxMode, bEnableDialogs); }
+    STDMETHOD_(void, SetGammaRamp)(THIS_ UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp)
+        { XXX; _DOCALL_NORET(SetGammaRamp, iSwapChain, Flags, pRamp); }
+    STDMETHOD_(void, GetGammaRamp)(THIS_ UINT iSwapChain,D3DGAMMARAMP* pRamp)
+        { XXX; _DOCALL_NORET(GetGammaRamp, iSwapChain, pRamp); }
+    STDMETHOD(CreateTexture)(THIS_ UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateTexture, Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
+		return AllocOverride(&hr, this, ppTexture);
+	}
+    STDMETHOD(CreateVolumeTexture)(THIS_ UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateVolumeTexture, Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture, pSharedHandle);
+		return AllocOverride(&hr, this, ppVolumeTexture);
+	}
+    STDMETHOD(CreateCubeTexture)(THIS_ UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateCubeTexture, EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture, pSharedHandle);
+		return AllocOverride(&hr, this, ppCubeTexture);
+	}
+    STDMETHOD(CreateVertexBuffer)(THIS_ UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateVertexBuffer, Length, Usage, FVF, Pool, ppVertexBuffer, pSharedHandle);
+		return AllocOverride(&hr, this, ppVertexBuffer);
+	}
+    STDMETHOD(CreateIndexBuffer)(THIS_ UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateIndexBuffer, Length, Usage, Format, Pool, ppIndexBuffer, pSharedHandle);
+		return AllocOverride(&hr, this, ppIndexBuffer);
+	}
+    STDMETHOD(CreateRenderTarget)(THIS_ UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultiSampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateRenderTarget, Width, Height, Format, MultiSample, MultiSampleQuality, Lockable, ppSurface, pSharedHandle);
+		return AllocOverride(&hr, this, ppSurface);
+	}
+    STDMETHOD(CreateDepthStencilSurface)(THIS_ UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultiSampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
+	{
+		XXX;
+        HRESULT hr = _DOCALL(CreateDepthStencilSurface, Width, Height, Format, MultiSample, MultiSampleQuality, Discard, ppSurface, pSharedHandle);
+		return AllocOverride(&hr, this, ppSurface);
+	}
+    STDMETHOD(UpdateSurface)(THIS_ IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint)
+		{ XXX; return _DOCALL(UpdateSurface, GetHWPtr(pSourceSurface), pSourceRect, GetHWPtr(pDestinationSurface), pDestPoint); }
+    STDMETHOD(UpdateTexture)(THIS_ IDirect3DBaseTexture9* pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture)
+		{ XXX; return _DOCALL(UpdateTexture, GetHWPtr(pSourceTexture), GetHWPtr(pDestinationTexture)); }
+    STDMETHOD(GetRenderTargetData)(THIS_ IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface)
+		{ XXX; return _DOCALL(GetRenderTargetData, GetHWPtr(pRenderTarget), GetHWPtr(pDestSurface)); }
+    STDMETHOD(GetFrontBufferData)(THIS_ UINT iSwapChain,IDirect3DSurface9* pDestSurface)
+		{ XXX; return _DOCALL(GetFrontBufferData, iSwapChain, GetHWPtr(pDestSurface)); }
+    STDMETHOD(StretchRect)(THIS_ IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter)
+		{ XXX; return _DOCALL(StretchRect, GetHWPtr(pSourceSurface), pSourceRect, GetHWPtr(pDestSurface), pDestRect, Filter); }
+    STDMETHOD(ColorFill)(THIS_ IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color)
+		{ XXX; return _DOCALL(ColorFill, GetHWPtr(pSurface), pRect, color); }
+    STDMETHOD(CreateOffscreenPlainSurface)(THIS_ UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateOffscreenPlainSurface, Width, Height, Format, Pool, ppSurface, pSharedHandle);
+		return AllocOverride(&hr, this, ppSurface);
+	}
+    
+	STDMETHOD(SetRenderTarget)(THIS_ DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetRenderTarget, RenderTargetIndex, GetHWPtr(pRenderTarget)); 
+		}
+#if D3D_BATCH_PERF_ANALYSIS
+		if ( m_batch_vis_bitmap.is_valid() && !RenderTargetIndex )
+		{
+			if ( pRenderTarget != m_pPrevRenderTarget0 )
+			{
+				m_batch_vis_bitmap.fill_box(0, m_nBatchVisY, m_batch_vis_bitmap.width(), 1, 30, 20, 20);
+				m_nBatchVisY += 1;
+			}
+		}
+		if ( !RenderTargetIndex )
+		{
+			m_pPrevRenderTarget0 = pRenderTarget;
+		}
+#endif
+		return hres;
+	}
+
+    STDMETHOD(GetRenderTarget)(THIS_ DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget)
+	{
+		XXX;
+		HRESULT hr =  _DOCALL(GetRenderTarget, RenderTargetIndex, ppRenderTarget);
+		return AllocOverride(&hr, this, ppRenderTarget);
+	}
+    STDMETHOD(SetDepthStencilSurface)(THIS_ IDirect3DSurface9* pNewZStencil)
+		{ XXX; return _DOCALL(SetDepthStencilSurface, GetHWPtr(pNewZStencil)); }
+    STDMETHOD(GetDepthStencilSurface)(THIS_ IDirect3DSurface9** ppZStencilSurface)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetDepthStencilSurface, ppZStencilSurface);
+		return AllocOverride(&hr, this, ppZStencilSurface);
+	}
+    STDMETHOD(BeginScene)(THIS)
+        { XXX; return _DOCALL0(BeginScene); }
+    STDMETHOD(EndScene)(THIS)
+        { XXX; return _DOCALL0(EndScene); }
+    STDMETHOD(Clear)(THIS_ DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil)
+		{ XXX; return _DOCALL(Clear, Count, pRects, Flags, Color, Z, Stencil); }
+    STDMETHOD(SetTransform)(THIS_ D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
+		{ XXX; return _DOCALL(SetTransform, State, pMatrix); }
+    STDMETHOD(GetTransform)(THIS_ D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix)
+        { XXX; return _DOCALL(GetTransform, State, pMatrix); }
+    STDMETHOD(MultiplyTransform)(THIS_ D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX *pMatrix)
+        { XXX; return _DOCALL(MultiplyTransform, State, pMatrix); }
+    STDMETHOD(SetViewport)(THIS_ CONST D3DVIEWPORT9* pViewport)
+        { XXX; return _DOCALL(SetViewport, pViewport); }
+    STDMETHOD(GetViewport)(THIS_ D3DVIEWPORT9* pViewport)
+        { XXX; return _DOCALL(GetViewport, pViewport); }
+    STDMETHOD(SetMaterial)(THIS_ CONST D3DMATERIAL9* pMaterial)
+        { XXX; return _DOCALL(SetMaterial, pMaterial); }
+    STDMETHOD(GetMaterial)(THIS_ D3DMATERIAL9* pMaterial)
+        { XXX; return _DOCALL(GetMaterial, pMaterial); }
+    STDMETHOD(SetLight)(THIS_ DWORD Index,CONST D3DLIGHT9* pLight)
+		{ XXX; return _DOCALL(SetLight, Index, pLight); }
+    STDMETHOD(GetLight)(THIS_ DWORD Index,D3DLIGHT9* pLight)
+        { XXX; return _DOCALL(GetLight, Index, pLight); }
+    STDMETHOD(LightEnable)(THIS_ DWORD Index,BOOL Enable)
+		{ XXX; return _DOCALL(LightEnable, Index, Enable); }
+    STDMETHOD(GetLightEnable)(THIS_ DWORD Index,BOOL* pEnable)
+        { XXX; return _DOCALL(GetLightEnable, Index, pEnable); }
+    STDMETHOD(SetClipPlane)(THIS_ DWORD Index,CONST float* pPlane)
+        { XXX; return _DOCALL(SetClipPlane, Index, pPlane);}
+    STDMETHOD(GetClipPlane)(THIS_ DWORD Index,float* pPlane)
+        { XXX; return _DOCALL(GetClipPlane, Index, pPlane); }
+    STDMETHOD(SetRenderState)(THIS_ D3DRENDERSTATETYPE State,DWORD Value)
+        { XXX; return _DOCALL(SetRenderState, State, Value); }
+    STDMETHOD(GetRenderState)(THIS_ D3DRENDERSTATETYPE State,DWORD* pValue)
+        { XXX; return _DOCALL(GetRenderState, State, pValue); }
+    STDMETHOD(CreateStateBlock)(THIS_ D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9** ppSB)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateStateBlock, Type, ppSB);
+		return AllocOverride(&hr, this, ppSB);
+	}
+    STDMETHOD(BeginStateBlock)(THIS)
+		{ XXX; return _DOCALL0(BeginStateBlock); }
+    STDMETHOD(EndStateBlock)(THIS_ IDirect3DStateBlock9** ppSB)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(EndStateBlock, ppSB);
+		return AllocOverride(&hr, this, ppSB);
+	}
+    STDMETHOD(SetClipStatus)(THIS_ CONST D3DCLIPSTATUS9* pClipStatus)
+        { XXX; return _DOCALL(SetClipStatus, pClipStatus);}
+    STDMETHOD(GetClipStatus)(THIS_ D3DCLIPSTATUS9* pClipStatus)
+        { XXX; return _DOCALL(GetClipStatus, pClipStatus);}
+    STDMETHOD(GetTexture)(THIS_ DWORD Stage,IDirect3DBaseTexture9** ppTexture)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetTexture, Stage, ppTexture);
+		return AllocOverride(&hr, this, ppTexture);
+	}
+    
+	STDMETHOD(SetTexture)(THIS_ DWORD Stage,IDirect3DBaseTexture9* pTexture)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetTexture, Stage, GetHWPtr(pTexture)); 
+		}
+		D3D_BATCH_PERF( m_batch_state.m_nNumSamplersChanged++; )
+		return hres;
+	}
+
+    STDMETHOD(GetTextureStageState)(THIS_ DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue)
+        { XXX; return _DOCALL(GetTextureStageState, Stage, Type, pValue); }
+    STDMETHOD(SetTextureStageState)(THIS_ DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value)
+        { XXX; return _DOCALL(SetTextureStageState, Stage, Type, Value); }
+    STDMETHOD(GetSamplerState)(THIS_ DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue)
+        { XXX; return _DOCALL(GetSamplerState, Sampler, Type, pValue); }
+    STDMETHOD(SetSamplerState)(THIS_ DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetSamplerState, Sampler, Type, Value); 
+		}
+		D3D_BATCH_PERF( m_batch_state.m_nNumSamplerStatesChanged++; )
+		return hres;
+	}
+
+    STDMETHOD(ValidateDevice)(THIS_ DWORD* pNumPasses)
+        { XXX; return _DOCALL(ValidateDevice, pNumPasses); }
+    STDMETHOD(SetPaletteEntries)(THIS_ UINT PaletteNumber,CONST PALETTEENTRY* pEntries)
+        { XXX; return _DOCALL(SetPaletteEntries, PaletteNumber, pEntries); }
+    STDMETHOD(GetPaletteEntries)(THIS_ UINT PaletteNumber,PALETTEENTRY* pEntries)
+        { XXX; return _DOCALL(GetPaletteEntries, PaletteNumber, pEntries); }
+    STDMETHOD(SetCurrentTexturePalette)(THIS_ UINT PaletteNumber)
+        { XXX; return _DOCALL(SetCurrentTexturePalette, PaletteNumber);}
+    STDMETHOD(GetCurrentTexturePalette)(THIS_ UINT *PaletteNumber)
+        { XXX; return _DOCALL(GetCurrentTexturePalette, PaletteNumber); }
+    STDMETHOD(SetScissorRect)(THIS_ CONST RECT* pRect)
+        { XXX; return _DOCALL(SetScissorRect, pRect); }
+    STDMETHOD(GetScissorRect)(THIS_ RECT* pRect)
+        { XXX; return _DOCALL(GetScissorRect, pRect); }
+    STDMETHOD(SetSoftwareVertexProcessing)(THIS_ BOOL bSoftware)
+        { XXX; return _DOCALL(SetSoftwareVertexProcessing, bSoftware); }
+    STDMETHOD_(BOOL, GetSoftwareVertexProcessing)(THIS)
+        { XXX; return _DOCALL0(GetSoftwareVertexProcessing); }
+    STDMETHOD(SetNPatchMode)(THIS_ float nSegments)
+        { XXX; return _DOCALL(SetNPatchMode, nSegments); }
+    STDMETHOD_(float, GetNPatchMode)(THIS)
+        { XXX; return _DOCALL0(GetNPatchMode);}
+    STDMETHOD(DrawPrimitive)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount)
+		{ XXX; m_nTotalDraws++; m_nTotalPrims += PrimitiveCount; return _DOCALL(DrawPrimitive, PrimitiveType, StartVertex, PrimitiveCount); }
+    STDMETHOD(DrawIndexedPrimitive)(THIS_ D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
+	{ 
+		m_nTotalDraws++;
+		m_nTotalPrims += primCount; 
+
+#if D3D_BATCH_PERF_ANALYSIS
+		CFastTimer tm;
+		if ( m_batch_vis_bitmap.is_valid() )
+		{
+			tm.Start();
+		}
+#endif
+
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(DrawIndexedPrimitive, PrimitiveType, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount); 
+		}
+		
+#if D3D_BATCH_PERF_ANALYSIS
+		if ( m_batch_vis_bitmap.is_valid() )
+		{
+			double t = tm.GetDurationInProgress().GetMillisecondsF();
+
+			uint h = 1;
+			if ( d3d_batch_vis_y_scale.GetFloat() > 0.0f)
+			{
+				h = ceil( t / d3d_batch_vis_y_scale.GetFloat() );
+				h = MAX(h, 1);
+			}
+
+			m_batch_vis_bitmap.fill_box(0, m_nBatchVisY, (uint)(.5f + t / d3d_batch_vis_abs_scale.GetFloat() * m_batch_vis_bitmap.width()), h, 64, 64, 64);
+
+			if ( s_rdtsc_to_ms == 0.0f )
+			{
+				TmU64 t0 = tmFastTime();
+				double d0 = Plat_FloatTime();
+
+				ThreadSleep( 1 );
+
+				TmU64 t1 = tmFastTime();
+				double d1 = Plat_FloatTime();
+
+				s_rdtsc_to_ms = ( 1000.0f * ( d1 - d0 ) ) / ( t1 - t0 );
+			}
+
+			double flTotalD3DCallMS = g_nTotalD3DCycles * s_rdtsc_to_ms;
+
+			m_batch_vis_bitmap.additive_fill_box(0, m_nBatchVisY, (uint)(.5f + flTotalD3DCallMS / d3d_batch_vis_abs_scale.GetFloat() * m_batch_vis_bitmap.width()), h, 96, 96, 128);
+
+			if (m_batch_state.m_bVertexShaderChanged) m_batch_vis_bitmap.additive_fill_box(0, m_nBatchVisY, 8, h, 0, 0, 64);
+			if (m_batch_state.m_bPixelShaderChanged) m_batch_vis_bitmap.additive_fill_box(32, m_nBatchVisY, 8, h, 64, 0, 64);
+
+			int lm = 80;
+			m_batch_vis_bitmap.fill_box(lm+0+0, m_nBatchVisY, m_batch_state.m_nNumVSConstants, h, 64, 255, 255);
+			m_batch_vis_bitmap.fill_box(lm+64+256+0, m_nBatchVisY, m_batch_state.m_nNumPSConstants, h, 64, 64, 255);
+
+			m_batch_vis_bitmap.fill_box(lm+64+256+32, m_nBatchVisY, m_batch_state.m_nNumSamplersChanged, h, 255, 255, 255);
+			m_batch_vis_bitmap.fill_box(lm+64+256+32+16, m_nBatchVisY, m_batch_state.m_nNumSamplerStatesChanged, h, 92, 128, 255);
+
+			if ( m_batch_state.m_bStreamSourceChanged) m_batch_vis_bitmap.fill_box(lm+64+256+32+16+64, m_nBatchVisY, 16, h, 128, 128, 128);
+			if ( m_batch_state.m_bIndicesChanged ) m_batch_vis_bitmap.fill_box(lm+64+256+32+16+64+16, m_nBatchVisY, 16, h, 128, 128, 255);
+
+			m_nBatchVisY += h;
+			
+			m_nTotalD3DCalls += g_nTotalD3DCalls;
+			m_flTotalD3DTime += flTotalD3DCallMS;
+			
+			g_nTotalD3DCycles = 0;
+			g_nTotalD3DCalls = 0;
+			
+			m_batch_state.Clear();
+		}
+#endif
+
+		return hres;
+	}
+
+    STDMETHOD(DrawPrimitiveUP)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
+		{ XXX; m_nTotalDraws++; m_nTotalPrims += PrimitiveCount; return _DOCALL(DrawPrimitiveUP, PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride); }
+    STDMETHOD(DrawIndexedPrimitiveUP)(THIS_ D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
+		{ XXX; m_nTotalDraws++; m_nTotalPrims += PrimitiveCount; return _DOCALL(DrawIndexedPrimitiveUP, PrimitiveType, MinVertexIndex, NumVertices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride); }
+    STDMETHOD(ProcessVertices)(THIS_ UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags)
+		{ XXX; return _DOCALL(ProcessVertices, SrcStartIndex, DestIndex, VertexCount, GetHWPtr(pDestBuffer), GetHWPtr(pVertexDecl), Flags); }
+    STDMETHOD(CreateVertexDeclaration)(THIS_ CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateVertexDeclaration, pVertexElements, ppDecl);
+		return AllocOverride(&hr, this, ppDecl);
+	}
+    STDMETHOD(SetVertexDeclaration)(THIS_ IDirect3DVertexDeclaration9* pDecl)
+		{ XXX; return _DOCALL(SetVertexDeclaration, GetHWPtr(pDecl)); }
+    STDMETHOD(GetVertexDeclaration)(THIS_ IDirect3DVertexDeclaration9** ppDecl)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetVertexDeclaration, ppDecl);
+		return AllocOverride(&hr, this, ppDecl);
+	}
+    STDMETHOD(SetFVF)(THIS_ DWORD FVF)
+		{ XXX; return _DOCALL(SetFVF, FVF); }
+    STDMETHOD(GetFVF)(THIS_ DWORD* pFVF)
+        { XXX; return _DOCALL(GetFVF, pFVF); }
+    STDMETHOD(CreateVertexShader)(THIS_ CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateVertexShader, pFunction, ppShader);
+		return AllocOverride(&hr, this, ppShader);
+	}
+    
+	STDMETHOD(SetVertexShader)(THIS_ IDirect3DVertexShader9* pShader)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetVertexShader, GetHWPtr(pShader)); 
+		}
+		D3D_BATCH_PERF( m_batch_state.m_bVertexShaderChanged = true; )
+		return hres;
+	}
+
+    STDMETHOD(GetVertexShader)(THIS_ IDirect3DVertexShader9** ppShader)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetVertexShader, ppShader);
+		return AllocOverride(&hr, this, ppShader);
+	}
+    
+	STDMETHOD(SetVertexShaderConstantF)(THIS_ UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetVertexShaderConstantF, StartRegister, pConstantData, Vector4fCount); 
+		}
+		D3D_BATCH_PERF( m_batch_state.m_nNumVSConstants += Vector4fCount; )
+		return hres;
+	}
+
+    STDMETHOD(GetVertexShaderConstantF)(THIS_ UINT StartRegister,float* pConstantData,UINT Vector4fCount)
+		{ XXX; return _DOCALL(GetVertexShaderConstantF, StartRegister, pConstantData, Vector4fCount);}
+    STDMETHOD(SetVertexShaderConstantI)(THIS_ UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
+		{ XXX; return _DOCALL(SetVertexShaderConstantI, StartRegister, pConstantData, Vector4iCount); }
+    STDMETHOD(GetVertexShaderConstantI)(THIS_ UINT StartRegister,int* pConstantData,UINT Vector4iCount)
+		{ XXX; return _DOCALL(GetVertexShaderConstantI, StartRegister, pConstantData, Vector4iCount); }
+    STDMETHOD(SetVertexShaderConstantB)(THIS_ UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount)
+		{ XXX; return _DOCALL(SetVertexShaderConstantB, StartRegister, pConstantData, BoolCount); }
+    STDMETHOD(GetVertexShaderConstantB)(THIS_ UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
+		{ XXX; return _DOCALL(GetVertexShaderConstantB, StartRegister, pConstantData, BoolCount); }
+		    
+	STDMETHOD(SetStreamSource)(THIS_ UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
+		
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetStreamSource, StreamNumber, GetHWPtr(pStreamData), OffsetInBytes, Stride);
+		}
+
+		D3D_BATCH_PERF( m_batch_state.m_bStreamSourceChanged = true; )
+
+		return hres;
+	}
+
+    STDMETHOD(GetStreamSource)(THIS_ UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetStreamSource, StreamNumber, ppStreamData, OffsetInBytes, pStride);
+		return AllocOverride(&hr, this, ppStreamData);
+	}
+    STDMETHOD(SetStreamSourceFreq)(THIS_ UINT StreamNumber,UINT Divider)
+        { XXX; return _DOCALL(SetStreamSourceFreq, StreamNumber, Divider); }
+
+    STDMETHOD(GetStreamSourceFreq)(THIS_ UINT StreamNumber,UINT* Divider)
+        { XXX; return _DOCALL(GetStreamSourceFreq, StreamNumber, Divider); }
+    
+	STDMETHOD(SetIndices)(THIS_ IDirect3DIndexBuffer9* pIndexData)
+	{ 
+		HRESULT hres;
+
+		{
+			XXX; 
+			hres = _DOCALL(SetIndices, GetHWPtr(pIndexData)); 
+		}
+
+		D3D_BATCH_PERF( m_batch_state.m_bIndicesChanged = true; )
+
+		return hres;
+	}
+
+    STDMETHOD(GetIndices)(THIS_ IDirect3DIndexBuffer9** ppIndexData)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetIndices, ppIndexData);
+		return AllocOverride(&hr, this, ppIndexData);
+	}
+    STDMETHOD(CreatePixelShader)(THIS_ CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreatePixelShader, pFunction, ppShader);
+		return AllocOverride(&hr, this, ppShader);
+	}
+    
+	STDMETHOD(SetPixelShader)(THIS_ IDirect3DPixelShader9* pShader)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetPixelShader, GetHWPtr(pShader)); 
+		}
+		D3D_BATCH_PERF( m_batch_state.m_bPixelShaderChanged = true; )
+		return hres;
+	}
+
+    STDMETHOD(GetPixelShader)(THIS_ IDirect3DPixelShader9** ppShader)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(GetPixelShader, ppShader);
+		return AllocOverride(&hr, this, ppShader);
+	}
+    
+	STDMETHOD(SetPixelShaderConstantF)(THIS_ UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
+	{ 
+		HRESULT hres;
+		{
+			XXX; 
+			hres = _DOCALL(SetPixelShaderConstantF, StartRegister, pConstantData, Vector4fCount); 
+		}
+		D3D_BATCH_PERF( m_batch_state.m_nNumPSConstants += Vector4fCount; )
+		return hres;
+	}
+
+    STDMETHOD(GetPixelShaderConstantF)(THIS_ UINT StartRegister,float* pConstantData,UINT Vector4fCount)
+		{ XXX; return _DOCALL(GetPixelShaderConstantF, StartRegister, pConstantData, Vector4fCount); }
+    STDMETHOD(SetPixelShaderConstantI)(THIS_ UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
+		{ XXX; return _DOCALL(SetPixelShaderConstantI, StartRegister, pConstantData, Vector4iCount); }
+    STDMETHOD(GetPixelShaderConstantI)(THIS_ UINT StartRegister,int* pConstantData,UINT Vector4iCount)
+		{ XXX; return _DOCALL(GetPixelShaderConstantI, StartRegister, pConstantData, Vector4iCount); }
+    STDMETHOD(SetPixelShaderConstantB)(THIS_ UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount)
+		{ XXX; return _DOCALL(SetPixelShaderConstantB, StartRegister, pConstantData, BoolCount); }
+    STDMETHOD(GetPixelShaderConstantB)(THIS_ UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
+		{ XXX; return _DOCALL(GetPixelShaderConstantB, StartRegister, pConstantData, BoolCount); }
+    STDMETHOD(DrawRectPatch)(THIS_ UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo)
+        { XXX; return _DOCALL(DrawRectPatch, Handle, pNumSegs, pRectPatchInfo);}
+    STDMETHOD(DrawTriPatch)(THIS_ UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo)
+        { XXX; return _DOCALL(DrawTriPatch, Handle, pNumSegs, pTriPatchInfo); }
+    STDMETHOD(DeletePatch)(THIS_ UINT Handle)
+        { XXX; return _DOCALL(DeletePatch, Handle);}
+    STDMETHOD(CreateQuery)(THIS_ D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateQuery, Type, ppQuery);
+		return AllocOverride(&hr, this, ppQuery);
+	}
+
+private:
+
+#if D3D_BATCH_PERF_ANALYSIS
+	IDirect3DSurface9* m_pPrevRenderTarget0;
+	simple_bitmap m_batch_vis_bitmap;
+	uint m_nBatchVisY;
+	uint m_nBatchVisFrameIndex, m_nBatchVisFileIdx;
+	
+	struct BatchState_t
+	{
+		void Clear() { memset(this, 0, sizeof(*this)); }
+
+		bool m_bStreamSourceChanged;
+		bool m_bIndicesChanged;
+		bool m_bPixelShaderChanged;
+		bool m_bVertexShaderChanged;
+		uint m_nNumPSConstants;
+		uint m_nNumVSConstants;
+		uint m_nNumSamplersChanged;
+		uint m_nNumSamplerStatesChanged;
+	};
+
+	BatchState_t m_batch_state;
+	
+	uint m_nTotalFrames;
+
+	uint m_nTotalDraws;
+	uint m_nTotalPrims;
+	uint m_nTotalD3DCalls;
+	double m_flTotalD3DTime;
+
+	uint m_nOverallDraws;
+	uint m_nOverallPrims;
+	uint m_nOverallD3DCalls;
+	double m_flOverallD3DTime;
+#endif
+};
+
+class CDirect3D9Hook : public CDx9HookBase<IDirect3D9>, public IDirect3D9
+{
+public:
+    /*** IUnknown methods ***/
+    IMPL_IUNKOWN();
+
+    // IDirect3D9 methods
+    STDMETHOD(RegisterSoftwareDevice)(THIS_ void* pInitializeFunction)
+		{ XXX; return _DOCALL(RegisterSoftwareDevice, pInitializeFunction); }
+    STDMETHOD_(UINT, GetAdapterCount)(THIS)
+		{ XXX; return _DOCALL0(GetAdapterCount); }
+    STDMETHOD(GetAdapterIdentifier)(THIS_ UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier)
+		{ XXX; return _DOCALL(GetAdapterIdentifier, Adapter, Flags, pIdentifier);}
+    STDMETHOD_(UINT, GetAdapterModeCount)(THIS_ UINT Adapter,D3DFORMAT Format)
+		{ XXX; return _DOCALL(GetAdapterModeCount, Adapter, Format);}
+    STDMETHOD(EnumAdapterModes)(THIS_ UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode)
+		{ XXX; return _DOCALL(EnumAdapterModes, Adapter, Format, Mode, pMode); }
+    STDMETHOD(GetAdapterDisplayMode)(THIS_ UINT Adapter,D3DDISPLAYMODE* pMode)
+		{ XXX; return _DOCALL(GetAdapterDisplayMode, Adapter, pMode); }
+    STDMETHOD(CheckDeviceType)(THIS_ UINT iAdapter,D3DDEVTYPE DevType,D3DFORMAT DisplayFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed)
+		{ XXX; return _DOCALL(CheckDeviceType, iAdapter, DevType, DisplayFormat, BackBufferFormat, bWindowed); }
+    STDMETHOD(CheckDeviceFormat)(THIS_ UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat)
+		{ XXX; return _DOCALL(CheckDeviceFormat, Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat); }
+    STDMETHOD(CheckDeviceMultiSampleType)(THIS_ UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels)
+		{ XXX; return _DOCALL(CheckDeviceMultiSampleType, Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType, pQualityLevels); }
+    STDMETHOD(CheckDepthStencilMatch)(THIS_ UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat)
+		{ XXX; return _DOCALL(CheckDepthStencilMatch, Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat); }
+    STDMETHOD(CheckDeviceFormatConversion)(THIS_ UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat)
+		{ XXX; return _DOCALL(CheckDeviceFormatConversion, Adapter, DeviceType, SourceFormat, TargetFormat); }
+    STDMETHOD(GetDeviceCaps)(THIS_ UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps)
+		{ XXX; return _DOCALL(GetDeviceCaps, Adapter, DeviceType, pCaps); }
+    STDMETHOD_(HMONITOR, GetAdapterMonitor)(THIS_ UINT Adapter)
+		{ XXX; return _DOCALL(GetAdapterMonitor, Adapter); }
+    STDMETHOD(CreateDevice)(THIS_ UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface)
+	{
+		XXX;
+		HRESULT hr = _DOCALL(CreateDevice, Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface);
+
+		if( SUCCEEDED( hr ) && ppReturnedDeviceInterface && *ppReturnedDeviceInterface )
+		{
+			CDirect3DDevice9Hook *pDevice = new CDirect3DDevice9Hook;
+			if(!pDevice)
+			{
+				( *ppReturnedDeviceInterface )->Release();
+				hr = E_OUTOFMEMORY;
+				return NULL;
+			}
+			pDevice->m_Data.pDevice = pDevice;
+			pDevice->m_Data.pHWObj = *ppReturnedDeviceInterface;
+			*ppReturnedDeviceInterface = pDevice;
+		}
+		return hr;
+	}
+};
+
+inline IDirect3D9 *Direct3DCreate9Hook( UINT SDKVersion )
+{
+	HRESULT hr = S_OK;
+	IDirect3D9 *pD3D = Direct3DCreate9( D3D_SDK_VERSION );
+	AllocOverride( &hr, NULL, &pD3D );
+	return pD3D;
+}
+
+#endif // _DX9HOOK_H_