#include "RenderPCH.h" #include "DriverD3D9.h" #define ecase(e) case e: return #e static char sStr[1024]; #define edefault(e) default: sprintf(sStr, "0x%x", e); return sStr; #define eflag(e) \ if (Flag & e) \ { \ if (sStr[0]) \ strcat (sStr, " | "); \ strcat(sStr, #e); \ } \ static char *sHex (DWORD Value) { sprintf(sStr, "0x%x", Value); return sStr; } static char *sInt (DWORD Value) { sprintf(sStr, "%d", Value); return sStr; } static char *sDWFloat (DWORD Value) { float fVal = *((float*)(&Value)); sprintf(sStr, "%.3f", fVal); return sStr; } static char *sBool (DWORD Value) { switch (Value) { ecase (FALSE); ecase (TRUE); edefault (Value); } } static char *sD3DZB (DWORD Value) { switch (Value) { ecase (D3DZB_FALSE); ecase (D3DZB_TRUE); ecase (D3DZB_USEW); edefault (Value); } } static char *sD3DFILL (DWORD Value) { switch (Value) { ecase (D3DFILL_POINT); ecase (D3DFILL_WIREFRAME); ecase (D3DFILL_SOLID); edefault (Value); } } static char *sD3DSHADE (DWORD Value) { switch (Value) { ecase (D3DSHADE_FLAT); ecase (D3DSHADE_GOURAUD); ecase (D3DSHADE_PHONG); edefault (Value); } } static char *sD3DBLEND (DWORD Value) { switch (Value) { ecase (D3DBLEND_ZERO); ecase (D3DBLEND_ONE); ecase (D3DBLEND_SRCCOLOR); ecase (D3DBLEND_INVSRCCOLOR); ecase (D3DBLEND_SRCALPHA); ecase (D3DBLEND_INVSRCALPHA); ecase (D3DBLEND_DESTALPHA); ecase (D3DBLEND_INVDESTALPHA); ecase (D3DBLEND_DESTCOLOR); ecase (D3DBLEND_INVDESTCOLOR); ecase (D3DBLEND_SRCALPHASAT); ecase (D3DBLEND_BOTHSRCALPHA); ecase (D3DBLEND_BOTHINVSRCALPHA); ecase (D3DBLEND_BLENDFACTOR); ecase (D3DBLEND_INVBLENDFACTOR); edefault (Value); } } static char *sD3DCULL (DWORD Value) { switch (Value) { ecase (D3DCULL_NONE); ecase (D3DCULL_CW); ecase (D3DCULL_CCW); edefault (Value); } } static char *sD3DCMP (DWORD Value) { switch(Value) { ecase (D3DCMP_NEVER); ecase (D3DCMP_LESS); ecase (D3DCMP_EQUAL); ecase (D3DCMP_LESSEQUAL); ecase (D3DCMP_GREATER); ecase (D3DCMP_NOTEQUAL); ecase (D3DCMP_GREATEREQUAL); ecase (D3DCMP_ALWAYS); edefault (Value); } } static char *sD3DFOG (DWORD Value) { switch(Value) { ecase (D3DFOG_NONE); ecase (D3DFOG_EXP); ecase (D3DFOG_EXP2); ecase (D3DFOG_LINEAR); edefault (Value); } } static char *sD3DSTENCILOP (DWORD Value) { switch(Value) { ecase (D3DSTENCILOP_KEEP); ecase (D3DSTENCILOP_ZERO); ecase (D3DSTENCILOP_REPLACE); ecase (D3DSTENCILOP_INCRSAT); ecase (D3DSTENCILOP_DECRSAT); ecase (D3DSTENCILOP_INVERT); ecase (D3DSTENCILOP_INCR); ecase (D3DSTENCILOP_DECR); edefault (Value); } } static char *sD3DMCS (DWORD Value) { switch (Value) { ecase (D3DMCS_MATERIAL); ecase (D3DMCS_COLOR1); ecase (D3DMCS_COLOR2); edefault (Value); } } static char *sD3DVBF (DWORD Value) { switch (Value) { ecase (D3DVBF_DISABLE); ecase (D3DVBF_1WEIGHTS); ecase (D3DVBF_2WEIGHTS); ecase (D3DVBF_3WEIGHTS); ecase (D3DVBF_TWEENING); ecase (D3DVBF_0WEIGHTS); edefault (Value); } } static char *sD3DPATCHEDGE (DWORD Value) { switch (Value) { ecase (D3DPATCHEDGE_DISCRETE); ecase (D3DPATCHEDGE_CONTINUOUS); edefault (Value); } } static char *sD3DDMT (DWORD Value) { switch (Value) { ecase (D3DDMT_ENABLE); ecase (D3DDMT_DISABLE); edefault (Value); } } static char *sD3DBLENDOP (DWORD Value) { switch (Value) { ecase (D3DBLENDOP_ADD); ecase (D3DBLENDOP_SUBTRACT); ecase (D3DBLENDOP_REVSUBTRACT); ecase (D3DBLENDOP_MIN); ecase (D3DBLENDOP_MAX); edefault (Value); } } static char *sD3DDEGREE (DWORD Value) { switch (Value) { ecase (D3DDEGREE_LINEAR); ecase (D3DDEGREE_QUADRATIC); ecase (D3DDEGREE_CUBIC); ecase (D3DDEGREE_QUINTIC); edefault (Value); } } static char *sD3DTOP (DWORD Value) { switch (Value) { ecase (D3DTOP_DISABLE); ecase (D3DTOP_SELECTARG1); ecase (D3DTOP_SELECTARG2); ecase (D3DTOP_MODULATE); ecase (D3DTOP_MODULATE2X); ecase (D3DTOP_MODULATE4X); ecase (D3DTOP_ADD); ecase (D3DTOP_ADDSIGNED); ecase (D3DTOP_ADDSIGNED2X); ecase (D3DTOP_SUBTRACT); ecase (D3DTOP_ADDSMOOTH); ecase (D3DTOP_BLENDDIFFUSEALPHA); ecase (D3DTOP_BLENDTEXTUREALPHA); ecase (D3DTOP_BLENDFACTORALPHA); ecase (D3DTOP_BLENDTEXTUREALPHAPM); ecase (D3DTOP_BLENDCURRENTALPHA); ecase (D3DTOP_PREMODULATE); ecase (D3DTOP_MODULATEALPHA_ADDCOLOR); ecase (D3DTOP_MODULATECOLOR_ADDALPHA); ecase (D3DTOP_MODULATEINVALPHA_ADDCOLOR); ecase (D3DTOP_MODULATEINVCOLOR_ADDALPHA); ecase (D3DTOP_BUMPENVMAP); ecase (D3DTOP_BUMPENVMAPLUMINANCE); ecase (D3DTOP_DOTPRODUCT3); ecase (D3DTOP_MULTIPLYADD); ecase (D3DTOP_LERP); edefault (Value); } } static char *sD3DPT (DWORD Value) { switch (Value) { ecase (D3DPT_POINTLIST); ecase (D3DPT_LINELIST); ecase (D3DPT_LINESTRIP); ecase (D3DPT_TRIANGLELIST); ecase (D3DPT_TRIANGLESTRIP); ecase (D3DPT_TRIANGLEFAN); edefault (Value); } } static char *sD3DTA (DWORD Value) { switch (Value) { ecase (D3DTA_CURRENT); ecase (D3DTA_DIFFUSE); ecase (D3DTA_SELECTMASK); ecase (D3DTA_SPECULAR); ecase (D3DTA_TEMP); ecase (D3DTA_TEXTURE); ecase (D3DTA_TFACTOR); edefault (Value); } } static char *sTEXCOORDINDEX (DWORD Value) { sprintf(sStr, "%d", Value & 0xf); if (Value & D3DTSS_TCI_CAMERASPACENORMAL) strcat (sStr, " | D3DTSS_TCI_CAMERASPACENORMAL"); else if (Value & D3DTSS_TCI_CAMERASPACEPOSITION) strcat (sStr, " | D3DTSS_TCI_CAMERASPACEPOSITION"); else if (Value & D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR) strcat (sStr, " | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR"); else if (Value & D3DTSS_TCI_SPHEREMAP) strcat (sStr, " | D3DTSS_TCI_SPHEREMAP"); else strcat (sStr, " | D3DTSS_TCI_PASSTHRU"); return sStr; } static char *sD3DTTFF (DWORD Value) { switch(Value & 0xf) { case D3DTTFF_DISABLE: strcpy(sStr, "D3DTTFF_DISABLE"); break; case D3DTTFF_COUNT1: strcpy(sStr, "D3DTTFF_COUNT1"); break; case D3DTTFF_COUNT2: strcpy(sStr, "D3DTTFF_COUNT2"); break; case D3DTTFF_COUNT3: strcpy(sStr, "D3DTTFF_COUNT3"); break; case D3DTTFF_COUNT4: strcpy(sStr, "D3DTTFF_COUNT4"); break; default: sprintf(sStr, "0x%x", Value & 0xf); } if (Value & D3DTTFF_PROJECTED) strcat (sStr, " | D3DTTFF_PROJECTED"); return sStr; } static char *sD3DTADDRESS (DWORD Value) { switch (Value) { ecase (D3DTADDRESS_WRAP); ecase (D3DTADDRESS_MIRROR); ecase (D3DTADDRESS_CLAMP); ecase (D3DTADDRESS_BORDER); ecase (D3DTADDRESS_MIRRORONCE); edefault (Value); } } static char *sD3DTEXF (DWORD Value) { switch (Value) { ecase (D3DTEXF_NONE); ecase (D3DTEXF_POINT); ecase (D3DTEXF_LINEAR); ecase (D3DTEXF_ANISOTROPIC); ecase (D3DTEXF_PYRAMIDALQUAD); ecase (D3DTEXF_GAUSSIANQUAD); edefault (Value); } } static char *sD3DTS (DWORD Value) { switch(Value) { ecase (D3DTS_VIEW); ecase (D3DTS_PROJECTION); ecase (D3DTS_TEXTURE0); ecase (D3DTS_TEXTURE1); ecase (D3DTS_TEXTURE2); ecase (D3DTS_TEXTURE3); ecase (D3DTS_TEXTURE4); ecase (D3DTS_TEXTURE5); ecase (D3DTS_TEXTURE6); ecase (D3DTS_TEXTURE7); edefault (Value); } } static char *sD3DCLEARFLAGS (DWORD Value) { if (!(Value & (D3DCLEAR_TARGET | D3DCLEAR_STENCIL | D3DCLEAR_ZBUFFER))) sprintf(sStr, "0x%x", Value); else { sStr[0] = 0; if (Value & D3DCLEAR_TARGET) strcat(sStr, "D3DCLEAR_TARGET"); if (Value & D3DCLEAR_ZBUFFER) { if (sStr[0]) strcat (sStr, " | "); strcat(sStr, "D3DCLEAR_ZBUFFER"); } if (Value & D3DCLEAR_STENCIL) { if (sStr[0]) strcat (sStr, " | "); strcat(sStr, "D3DCLEAR_STENCIL"); } } return sStr; } static char *sFVF (DWORD Flag) { sStr[0] = 0; eflag(D3DFVF_XYZ); eflag(D3DFVF_XYZRHW); eflag(D3DFVF_NORMAL); eflag(D3DFVF_PSIZE); eflag(D3DFVF_DIFFUSE); eflag(D3DFVF_SPECULAR); char ss[128]; if(Flag & 0xf00) { sprintf(ss, "D3DFVF_TEX%d", (Flag >> 8)&0xf); if (sStr[0]) strcat (sStr, " | "); strcat(sStr, ss); } return sStr; } //========================================================================================= HRESULT CMyDirect3DDevice9::QueryInterface(REFIID riid, void** ppvObj) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::QueryInterface"); return gcpRendD3D->m_pActuald3dDevice->QueryInterface(riid, ppvObj); } ULONG CMyDirect3DDevice9::AddRef() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::AddRef"); return gcpRendD3D->m_pActuald3dDevice->AddRef(); } ULONG CMyDirect3DDevice9::Release() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::Release"); return gcpRendD3D->m_pActuald3dDevice->Release(); } /*** IDirect3DDevice9 methods ***/ HRESULT CMyDirect3DDevice9::TestCooperativeLevel() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::TestCooperativeLevel"); return gcpRendD3D->m_pActuald3dDevice->TestCooperativeLevel(); } UINT CMyDirect3DDevice9::GetAvailableTextureMem() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetAvailableTextureMem"); return gcpRendD3D->m_pActuald3dDevice->GetAvailableTextureMem(); } HRESULT CMyDirect3DDevice9::EvictManagedResources() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::EvictManagedResources"); return gcpRendD3D->m_pActuald3dDevice->EvictManagedResources(); } HRESULT CMyDirect3DDevice9::GetDirect3D(IDirect3D9** ppD3D9) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetDirect3D"); return gcpRendD3D->m_pActuald3dDevice->GetDirect3D(ppD3D9); } HRESULT CMyDirect3DDevice9::GetDeviceCaps(D3DCAPS9* pCaps) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetDeviceCaps"); return gcpRendD3D->m_pActuald3dDevice->GetDeviceCaps(pCaps); } HRESULT CMyDirect3DDevice9::GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetDisplayMode"); return gcpRendD3D->m_pActuald3dDevice->GetDisplayMode(iSwapChain, pMode); } HRESULT CMyDirect3DDevice9::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetCreationParameters"); return gcpRendD3D->m_pActuald3dDevice->GetCreationParameters(pParameters); } HRESULT CMyDirect3DDevice9::SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9* pCursorBitmap) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetCursorProperties"); return gcpRendD3D->m_pActuald3dDevice->SetCursorProperties(XHotSpot,YHotSpot,pCursorBitmap); } void CMyDirect3DDevice9::SetCursorPosition(int X,int Y,DWORD Flags) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetCursorPosition"); return gcpRendD3D->m_pActuald3dDevice->SetCursorPosition(X,Y,Flags); } BOOL CMyDirect3DDevice9::ShowCursor(BOOL bShow) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::ShowCursor"); return gcpRendD3D->m_pActuald3dDevice->ShowCursor(bShow); } HRESULT CMyDirect3DDevice9::CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9** pSwapChain) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateAdditionalSwapChain"); return gcpRendD3D->m_pActuald3dDevice->CreateAdditionalSwapChain( pPresentationParameters, pSwapChain); } HRESULT CMyDirect3DDevice9::GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9** pSwapChain) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetSwapChain"); return gcpRendD3D->m_pActuald3dDevice->GetSwapChain(iSwapChain,pSwapChain); } UINT CMyDirect3DDevice9::GetNumberOfSwapChains() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetNumberOfSwapChains"); return gcpRendD3D->m_pActuald3dDevice->GetNumberOfSwapChains(); } HRESULT CMyDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::Reset"); return gcpRendD3D->m_pActuald3dDevice->Reset(pPresentationParameters); } HRESULT CMyDirect3DDevice9::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::Present"); return gcpRendD3D->m_pActuald3dDevice->Present(pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion); } HRESULT CMyDirect3DDevice9::GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetBackBuffer"); return gcpRendD3D->m_pActuald3dDevice->GetBackBuffer(iSwapChain,iBackBuffer,Type,ppBackBuffer); } HRESULT CMyDirect3DDevice9::GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetRasterStatus"); return gcpRendD3D->m_pActuald3dDevice->GetRasterStatus(iSwapChain,pRasterStatus); } HRESULT CMyDirect3DDevice9::SetDialogBoxMode(BOOL bEnableDialogs) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetDialogBoxMode"); return gcpRendD3D->m_pActuald3dDevice->SetDialogBoxMode(bEnableDialogs); } void CMyDirect3DDevice9::SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetGammaRamp"); return gcpRendD3D->m_pActuald3dDevice->SetGammaRamp(iSwapChain,Flags,pRamp); } void CMyDirect3DDevice9::GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetGammaRamp"); return gcpRendD3D->m_pActuald3dDevice->GetGammaRamp(iSwapChain,pRamp); } HRESULT CMyDirect3DDevice9::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateTexture"); return gcpRendD3D->m_pActuald3dDevice->CreateTexture(Width,Height,Levels,Usage,Format,Pool,ppTexture,pSharedHandle); } HRESULT CMyDirect3DDevice9::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateVolumeTexture"); return gcpRendD3D->m_pActuald3dDevice->CreateVolumeTexture(Width,Height,Depth,Levels,Usage,Format,Pool,ppVolumeTexture,pSharedHandle); } HRESULT CMyDirect3DDevice9::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateCubeTexture"); return gcpRendD3D->m_pActuald3dDevice->CreateCubeTexture(EdgeLength,Levels,Usage,Format,Pool,ppCubeTexture,pSharedHandle); } HRESULT CMyDirect3DDevice9::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateVertexBuffer"); return gcpRendD3D->m_pActuald3dDevice->CreateVertexBuffer(Length,Usage,FVF,Pool, ppVertexBuffer, pSharedHandle); } HRESULT CMyDirect3DDevice9::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateIndexBuffer"); return gcpRendD3D->m_pActuald3dDevice->CreateIndexBuffer(Length,Usage,Format,Pool, ppIndexBuffer,pSharedHandle); } HRESULT CMyDirect3DDevice9::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateRenderTarget"); return gcpRendD3D->m_pActuald3dDevice->CreateRenderTarget(Width,Height,Format,MultiSample,MultisampleQuality,Lockable, ppSurface,pSharedHandle); } HRESULT CMyDirect3DDevice9::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateDepthStencilSurface"); return gcpRendD3D->m_pActuald3dDevice->CreateDepthStencilSurface(Width,Height,Format,MultiSample,MultisampleQuality,Discard, ppSurface, pSharedHandle); } HRESULT CMyDirect3DDevice9::UpdateSurface(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::UpdateSurface"); return gcpRendD3D->m_pActuald3dDevice->UpdateSurface(pSourceSurface,pSourceRect,pDestinationSurface, pDestPoint); } HRESULT CMyDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9* pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::UpdateTexture"); return gcpRendD3D->m_pActuald3dDevice->UpdateTexture(pSourceTexture,pDestinationTexture); } HRESULT CMyDirect3DDevice9::GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetRenderTargetData"); return gcpRendD3D->m_pActuald3dDevice->GetRenderTargetData(pRenderTarget,pDestSurface); } HRESULT CMyDirect3DDevice9::GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetFrontBufferData"); return gcpRendD3D->m_pActuald3dDevice->GetFrontBufferData(iSwapChain,pDestSurface); } HRESULT CMyDirect3DDevice9::StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::StretchRect"); return gcpRendD3D->m_pActuald3dDevice->StretchRect(pSourceSurface,pSourceRect,pDestSurface,pDestRect,Filter); } HRESULT CMyDirect3DDevice9::ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::ColorFill"); return gcpRendD3D->m_pActuald3dDevice->ColorFill(pSurface,pRect,color); } HRESULT CMyDirect3DDevice9::CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateOffscreenPlainSurface"); return gcpRendD3D->m_pActuald3dDevice->CreateOffscreenPlainSurface(Width,Height,Format,Pool, ppSurface, pSharedHandle); } HRESULT CMyDirect3DDevice9::SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetRenderTarget"); return gcpRendD3D->m_pActuald3dDevice->SetRenderTarget(RenderTargetIndex,pRenderTarget); } HRESULT CMyDirect3DDevice9::GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetRenderTarget"); return gcpRendD3D->m_pActuald3dDevice->GetRenderTarget(RenderTargetIndex, ppRenderTarget); } HRESULT CMyDirect3DDevice9::SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetDepthStencilSurface"); return gcpRendD3D->m_pActuald3dDevice->SetDepthStencilSurface(pNewZStencil); } HRESULT CMyDirect3DDevice9::GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetDepthStencilSurface"); return gcpRendD3D->m_pActuald3dDevice->GetDepthStencilSurface(ppZStencilSurface); } HRESULT CMyDirect3DDevice9::BeginScene() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::BeginScene"); return gcpRendD3D->m_pActuald3dDevice->BeginScene(); } HRESULT CMyDirect3DDevice9::EndScene() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::EndScene"); return gcpRendD3D->m_pActuald3dDevice->EndScene(); } HRESULT CMyDirect3DDevice9::Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, 0x%x, %s, 0x%x, %.3f, 0x%x)\n", "D3DDevice::Clear", Count, pRects, sD3DCLEARFLAGS(Flags), Color, Z, Stencil); return gcpRendD3D->m_pActuald3dDevice->Clear(Count,pRects,Flags,Color,Z,Stencil); } HRESULT CMyDirect3DDevice9::SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) { char *state = sD3DTS(State); gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%s, 0x%x)\n", "D3DDevice::SetTransform", state, pMatrix); return gcpRendD3D->m_pActuald3dDevice->SetTransform(State,pMatrix); } HRESULT CMyDirect3DDevice9::GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetTransform"); return gcpRendD3D->m_pActuald3dDevice->GetTransform(State,pMatrix); } HRESULT CMyDirect3DDevice9::MultiplyTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::MultiplyTransform"); return gcpRendD3D->m_pActuald3dDevice->MultiplyTransform(State,pMatrix); } HRESULT CMyDirect3DDevice9::SetViewport(CONST D3DVIEWPORT9* pViewport) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d, %d, %d, %.3f, %.3f)\n", "D3DDevice::SetViewport", pViewport->X, pViewport->Y, pViewport->Width, pViewport->Height, pViewport->MinZ, pViewport->MaxZ); return gcpRendD3D->m_pActuald3dDevice->SetViewport(pViewport); } HRESULT CMyDirect3DDevice9::GetViewport(D3DVIEWPORT9* pViewport) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetViewport"); return gcpRendD3D->m_pActuald3dDevice->GetViewport(pViewport); } HRESULT CMyDirect3DDevice9::SetMaterial(CONST D3DMATERIAL9* pMaterial) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetMaterial"); return gcpRendD3D->m_pActuald3dDevice->SetMaterial(pMaterial); } HRESULT CMyDirect3DDevice9::GetMaterial(D3DMATERIAL9* pMaterial) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetMaterial"); return gcpRendD3D->m_pActuald3dDevice->GetMaterial(pMaterial); } HRESULT CMyDirect3DDevice9::SetLight(DWORD Index,CONST D3DLIGHT9* pLight) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, 0x%x)\n", "D3DDevice::SetLight", Index, pLight); return gcpRendD3D->m_pActuald3dDevice->SetLight(Index,pLight); } HRESULT CMyDirect3DDevice9::GetLight(DWORD Index,D3DLIGHT9* pLight) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetLight"); return gcpRendD3D->m_pActuald3dDevice->GetLight(Index,pLight); } HRESULT CMyDirect3DDevice9::LightEnable(DWORD Index,BOOL Enable) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s)\n", "D3DDevice::LightEnable", Index, sBool(Enable)); return gcpRendD3D->m_pActuald3dDevice->LightEnable(Index,Enable); } HRESULT CMyDirect3DDevice9::GetLightEnable(DWORD Index,BOOL* pEnable) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetLightEnable"); return gcpRendD3D->m_pActuald3dDevice->GetLightEnable(Index,pEnable); } HRESULT CMyDirect3DDevice9::SetClipPlane(DWORD Index,CONST float* pPlane) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetClipPlane"); return gcpRendD3D->m_pActuald3dDevice->SetClipPlane(Index,pPlane); } HRESULT CMyDirect3DDevice9::GetClipPlane(DWORD Index,float* pPlane) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetClipPlane"); return gcpRendD3D->m_pActuald3dDevice->GetClipPlane(Index,pPlane); } HRESULT CMyDirect3DDevice9::SetRenderState(D3DRENDERSTATETYPE State,DWORD Value) { #define ECASE(e) case e: state = #e char Str[1024]; #define EDEFAULT(e) default: sprintf(Str, "0x%x", e); state = Str; char *state; char *val = NULL; switch(State) { ECASE (D3DRS_ZENABLE); val = sD3DZB(Value); break; ECASE (D3DRS_FILLMODE); val = sD3DFILL(Value); break; ECASE (D3DRS_SHADEMODE); val = sD3DSHADE(Value); break; ECASE (D3DRS_ZWRITEENABLE); val = sBool(Value); break; ECASE (D3DRS_ALPHATESTENABLE); val = sBool(Value); break; ECASE (D3DRS_SRCBLEND); val = sD3DBLEND(Value); break; ECASE (D3DRS_DESTBLEND); val = sD3DBLEND(Value); break; ECASE (D3DRS_CULLMODE); val = sD3DCULL(Value); break; ECASE (D3DRS_ZFUNC); val = sD3DCMP(Value); break; ECASE (D3DRS_ALPHAREF); val = sInt(Value); break; ECASE (D3DRS_ALPHAFUNC); val = sD3DCMP(Value); break; ECASE (D3DRS_DITHERENABLE); val = sBool(Value); break; ECASE (D3DRS_ALPHABLENDENABLE); val = sBool(Value); break; ECASE (D3DRS_FOGENABLE); val = sBool(Value); break; ECASE (D3DRS_SPECULARENABLE); val = sBool(Value); break; ECASE (D3DRS_FOGCOLOR); val = sHex(Value); break; ECASE (D3DRS_FOGTABLEMODE); val = sD3DFOG(Value); break; ECASE (D3DRS_FOGSTART); val = sDWFloat(Value); break; ECASE (D3DRS_FOGEND); val = sDWFloat(Value); break; ECASE (D3DRS_FOGDENSITY); val = sDWFloat(Value); break; ECASE (D3DRS_RANGEFOGENABLE); val = sBool(Value); break; ECASE (D3DRS_STENCILENABLE); val = sBool(Value); break; ECASE (D3DRS_STENCILFAIL); val = sD3DSTENCILOP(Value); break; ECASE (D3DRS_STENCILZFAIL); val = sD3DSTENCILOP(Value); break; ECASE (D3DRS_STENCILPASS); val = sD3DSTENCILOP(Value); break; ECASE (D3DRS_STENCILFUNC); val = sD3DCMP(Value); break; ECASE (D3DRS_STENCILREF); val = sInt(Value); break; ECASE (D3DRS_STENCILMASK); val = sHex(Value); break; ECASE (D3DRS_STENCILWRITEMASK); val = sHex(Value); break; ECASE (D3DRS_TEXTUREFACTOR); val = sHex(Value); break; ECASE (D3DRS_WRAP0); val = sHex(Value); break; ECASE (D3DRS_WRAP1); val = sHex(Value); break; ECASE (D3DRS_WRAP2); val = sHex(Value); break; ECASE (D3DRS_WRAP3); val = sHex(Value); break; ECASE (D3DRS_WRAP4); val = sHex(Value); break; ECASE (D3DRS_WRAP5); val = sHex(Value); break; ECASE (D3DRS_WRAP6); val = sHex(Value); break; ECASE (D3DRS_WRAP7); val = sHex(Value); break; ECASE (D3DRS_CLIPPING); val = sBool(Value); break; ECASE (D3DRS_LIGHTING); val = sBool(Value); break; ECASE (D3DRS_AMBIENT); val = sHex(Value); break; ECASE (D3DRS_FOGVERTEXMODE); val = sD3DFOG(Value); break; ECASE (D3DRS_COLORVERTEX); val = sBool(Value); break; ECASE (D3DRS_LOCALVIEWER); val = sBool(Value); break; ECASE (D3DRS_NORMALIZENORMALS); val = sBool(Value); break; ECASE (D3DRS_DIFFUSEMATERIALSOURCE); val = sD3DMCS(Value); break; ECASE (D3DRS_SPECULARMATERIALSOURCE); val = sD3DMCS(Value); break; ECASE (D3DRS_AMBIENTMATERIALSOURCE); val = sD3DMCS(Value); break; ECASE (D3DRS_EMISSIVEMATERIALSOURCE); val = sD3DMCS(Value); break; ECASE (D3DRS_VERTEXBLEND); val = sD3DVBF(Value); break; ECASE (D3DRS_CLIPPLANEENABLE); val = sHex(Value); break; ECASE (D3DRS_POINTSIZE); val = sDWFloat(Value); break; ECASE (D3DRS_POINTSIZE_MIN); val = sDWFloat(Value); break; ECASE (D3DRS_POINTSPRITEENABLE); val = sBool(Value); break; ECASE (D3DRS_POINTSCALEENABLE); val = sBool(Value); break; ECASE (D3DRS_POINTSCALE_A); break; ECASE (D3DRS_POINTSCALE_B); val = sDWFloat(Value); break; ECASE (D3DRS_POINTSCALE_C); val = sDWFloat(Value); break; ECASE (D3DRS_MULTISAMPLEANTIALIAS); val = sBool(Value); break; ECASE (D3DRS_MULTISAMPLEMASK); val = sHex(Value); break; ECASE (D3DRS_PATCHEDGESTYLE); val = sD3DPATCHEDGE(Value); break; ECASE (D3DRS_DEBUGMONITORTOKEN); val = sD3DDMT(Value); break; ECASE (D3DRS_POINTSIZE_MAX); val = sDWFloat(Value); break; ECASE (D3DRS_INDEXEDVERTEXBLENDENABLE); val = sBool(Value); break; ECASE (D3DRS_COLORWRITEENABLE); val = sHex(Value); break; ECASE (D3DRS_TWEENFACTOR); val = sDWFloat(Value); break; ECASE (D3DRS_BLENDOP); val = sD3DBLENDOP(Value); break; ECASE (D3DRS_POSITIONDEGREE); val = sD3DDEGREE(Value); break; ECASE (D3DRS_NORMALDEGREE); val = sD3DDEGREE(Value); break; ECASE (D3DRS_SCISSORTESTENABLE); val = sBool(Value); break; ECASE (D3DRS_SLOPESCALEDEPTHBIAS); val = sHex(Value); break; ECASE (D3DRS_ANTIALIASEDLINEENABLE); val = sBool(Value); break; ECASE (D3DRS_MINTESSELLATIONLEVEL); val = sDWFloat(Value); break; ECASE (D3DRS_MAXTESSELLATIONLEVEL); val = sDWFloat(Value); break; ECASE (D3DRS_ADAPTIVETESS_X); val = sDWFloat(Value); break; ECASE (D3DRS_ADAPTIVETESS_Y); val = sDWFloat(Value); break; ECASE (D3DRS_ADAPTIVETESS_Z); val = sDWFloat(Value); break; ECASE (D3DRS_ADAPTIVETESS_W); val = sDWFloat(Value); break; ECASE (D3DRS_ENABLEADAPTIVETESSELLATION); val = sBool(Value); break; ECASE (D3DRS_TWOSIDEDSTENCILMODE); val = sBool(Value); break; ECASE (D3DRS_CCW_STENCILFAIL); val = sD3DSTENCILOP(Value); break; ECASE (D3DRS_CCW_STENCILZFAIL); val = sD3DSTENCILOP(Value); break; ECASE (D3DRS_CCW_STENCILPASS); val = sD3DSTENCILOP(Value); break; ECASE (D3DRS_CCW_STENCILFUNC); val = sD3DCMP(Value); break; ECASE (D3DRS_COLORWRITEENABLE1); val = sHex(Value); break; ECASE (D3DRS_COLORWRITEENABLE2); val = sHex(Value); break; ECASE (D3DRS_COLORWRITEENABLE3); val = sHex(Value); break; ECASE (D3DRS_BLENDFACTOR); val = sHex(Value); break; ECASE (D3DRS_SRGBWRITEENABLE); val = sBool(Value); break; ECASE (D3DRS_DEPTHBIAS); val = sDWFloat(Value); break; ECASE (D3DRS_WRAP8); val = sHex(Value); break; ECASE (D3DRS_WRAP9); val = sHex(Value); break; ECASE (D3DRS_WRAP10); val = sHex(Value); break; ECASE (D3DRS_WRAP11); val = sHex(Value); break; ECASE (D3DRS_WRAP12); val = sHex(Value); break; ECASE (D3DRS_WRAP13); val = sHex(Value); break; ECASE (D3DRS_WRAP14); val = sHex(Value); break; ECASE (D3DRS_WRAP15); val = sHex(Value); break; ECASE (D3DRS_SEPARATEALPHABLENDENABLE); val = sBool(Value); break; ECASE (D3DRS_SRCBLENDALPHA); val = sD3DBLEND(Value); break; ECASE (D3DRS_DESTBLENDALPHA); val = sD3DBLEND(Value); break; ECASE (D3DRS_BLENDOPALPHA); val = sD3DBLENDOP(Value); break; EDEFAULT (State); } if (!val) val = sHex(Value); gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s)\n", "D3DDevice::SetRenderState", state, val); return gcpRendD3D->m_pActuald3dDevice->SetRenderState(State,Value); #undef ECASE #undef EDEFAULT } HRESULT CMyDirect3DDevice9::GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetRenderState"); return gcpRendD3D->m_pActuald3dDevice->GetRenderState(State,pValue); } HRESULT CMyDirect3DDevice9::CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9** ppSB) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateStateBlock"); return gcpRendD3D->m_pActuald3dDevice->CreateStateBlock(Type,ppSB); } HRESULT CMyDirect3DDevice9::BeginStateBlock() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::BeginStateBlock"); return gcpRendD3D->m_pActuald3dDevice->BeginStateBlock(); } HRESULT CMyDirect3DDevice9::EndStateBlock(IDirect3DStateBlock9** ppSB) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::EndStateBlock"); return gcpRendD3D->m_pActuald3dDevice->EndStateBlock(ppSB); } HRESULT CMyDirect3DDevice9::SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetClipStatus"); return gcpRendD3D->m_pActuald3dDevice->SetClipStatus(pClipStatus); } HRESULT CMyDirect3DDevice9::GetClipStatus(D3DCLIPSTATUS9* pClipStatus) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetClipStatus"); return gcpRendD3D->m_pActuald3dDevice->GetClipStatus(pClipStatus); } HRESULT CMyDirect3DDevice9::GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetTexture"); return gcpRendD3D->m_pActuald3dDevice->GetTexture(Stage, ppTexture); } HRESULT CMyDirect3DDevice9::SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, 0x%x)\n", "D3DDevice::SetTexture", Stage, pTexture); return gcpRendD3D->m_pActuald3dDevice->SetTexture(Stage,pTexture); } HRESULT CMyDirect3DDevice9::GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetTextureStageState"); return gcpRendD3D->m_pActuald3dDevice->GetTextureStageState(Stage,Type,pValue); } HRESULT CMyDirect3DDevice9::SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value) { #define ECASE(e) case e: type = #e char Str[1024]; #define EDEFAULT(e) default: sprintf(Str, "0x%x", e); type = Str; char *type; char *val = NULL; switch (Type) { ECASE (D3DTSS_COLOROP); val = sD3DTOP(Value); break; ECASE (D3DTSS_COLORARG1); val = sD3DTA(Value); break; ECASE (D3DTSS_COLORARG2); val = sD3DTA(Value); break; ECASE (D3DTSS_ALPHAOP); val = sD3DTOP(Value); break; ECASE (D3DTSS_ALPHAARG1); val = sD3DTA(Value); break; ECASE (D3DTSS_ALPHAARG2); val = sD3DTA(Value); break; ECASE (D3DTSS_BUMPENVMAT00); val = sDWFloat(Value); break; ECASE (D3DTSS_BUMPENVMAT01); val = sDWFloat(Value); break; ECASE (D3DTSS_BUMPENVMAT10); val = sDWFloat(Value); break; ECASE (D3DTSS_BUMPENVMAT11); val = sDWFloat(Value); break; ECASE (D3DTSS_TEXCOORDINDEX); val = sTEXCOORDINDEX(Value); break; ECASE (D3DTSS_BUMPENVLSCALE); val = sDWFloat(Value); break; ECASE (D3DTSS_BUMPENVLOFFSET); val = sDWFloat(Value); break; ECASE (D3DTSS_TEXTURETRANSFORMFLAGS); val = sD3DTTFF(Value); break; ECASE (D3DTSS_COLORARG0); val = sD3DTA(Value); break; ECASE (D3DTSS_ALPHAARG0); val = sD3DTA(Value); break; ECASE (D3DTSS_RESULTARG); val = sD3DTA(Value); break; ECASE (D3DTSS_CONSTANT); val = sHex(Value); break; EDEFAULT (Type); } if (!val) val = sHex(Value); gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, %s)\n", "D3DDevice::SetTextureStageState", Stage, type, val); return gcpRendD3D->m_pActuald3dDevice->SetTextureStageState(Stage,Type,Value); #undef ECASE #undef EDEFAULT } HRESULT CMyDirect3DDevice9::GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetSamplerState"); return gcpRendD3D->m_pActuald3dDevice->GetSamplerState(Sampler,Type, pValue); } HRESULT CMyDirect3DDevice9::SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value) { #define ECASE(e) case e: type = #e char Str[1024]; #define EDEFAULT(e) default: sprintf(Str, "0x%x", e); type = Str; char *type; char *val = NULL; switch(Type) { ECASE (D3DSAMP_ADDRESSU); val = sD3DTADDRESS(Value); break; ECASE (D3DSAMP_ADDRESSV); val = sD3DTADDRESS(Value); break; ECASE (D3DSAMP_ADDRESSW); val = sD3DTADDRESS(Value); break; ECASE (D3DSAMP_BORDERCOLOR); val = sHex(Value); break; ECASE (D3DSAMP_MAGFILTER); val = sD3DTEXF(Value); break; ECASE (D3DSAMP_MINFILTER); val = sD3DTEXF(Value); break; ECASE (D3DSAMP_MIPFILTER); val = sD3DTEXF(Value); break; ECASE (D3DSAMP_MIPMAPLODBIAS); val = sDWFloat(Value); break; ECASE (D3DSAMP_MAXMIPLEVEL); val = sInt(Value); break; ECASE (D3DSAMP_MAXANISOTROPY); val = sInt(Value); break; ECASE (D3DSAMP_SRGBTEXTURE); val = sBool(Value); break; ECASE (D3DSAMP_ELEMENTINDEX); val = sInt(Value); break; ECASE (D3DSAMP_DMAPOFFSET); val = sInt(Value); break; EDEFAULT (Type); } if (!val) val = sHex(Value); gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, %s)\n", "D3DDevice::SetSamplerState", Sampler, type, val); return gcpRendD3D->m_pActuald3dDevice->SetSamplerState(Sampler,Type,Value); #undef ECASE #undef EDEFAULT } HRESULT CMyDirect3DDevice9::ValidateDevice(DWORD* pNumPasses) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::ValidateDevice"); return gcpRendD3D->m_pActuald3dDevice->ValidateDevice(pNumPasses); } HRESULT CMyDirect3DDevice9::SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetPaletteEntries"); return gcpRendD3D->m_pActuald3dDevice->SetPaletteEntries(PaletteNumber,pEntries); } HRESULT CMyDirect3DDevice9::GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetPaletteEntries"); return gcpRendD3D->m_pActuald3dDevice->GetPaletteEntries(PaletteNumber,pEntries); } HRESULT CMyDirect3DDevice9::SetCurrentTexturePalette(UINT PaletteNumber) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetCurrentTexturePalette"); return gcpRendD3D->m_pActuald3dDevice->SetCurrentTexturePalette(PaletteNumber); } HRESULT CMyDirect3DDevice9::GetCurrentTexturePalette(UINT *PaletteNumber) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetCurrentTexturePalette"); return gcpRendD3D->m_pActuald3dDevice->GetCurrentTexturePalette(PaletteNumber); } HRESULT CMyDirect3DDevice9::SetScissorRect(CONST RECT* pRect) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s(%d, %d, %d, %d)\n", "D3DDevice::SetScissorRect", pRect->left, pRect->right, pRect->top, pRect->bottom); return gcpRendD3D->m_pActuald3dDevice->SetScissorRect(pRect); } HRESULT CMyDirect3DDevice9::GetScissorRect(RECT* pRect) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetScissorRect"); return gcpRendD3D->m_pActuald3dDevice->GetScissorRect(pRect); } HRESULT CMyDirect3DDevice9::SetSoftwareVertexProcessing(BOOL bSoftware) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetSoftwareVertexProcessing"); return gcpRendD3D->m_pActuald3dDevice->SetSoftwareVertexProcessing(bSoftware); } BOOL CMyDirect3DDevice9::GetSoftwareVertexProcessing() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetSoftwareVertexProcessing"); return gcpRendD3D->m_pActuald3dDevice->GetSoftwareVertexProcessing(); } HRESULT CMyDirect3DDevice9::SetNPatchMode(float nSegments) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetNPatchMode"); return gcpRendD3D->m_pActuald3dDevice->SetNPatchMode(nSegments); } float CMyDirect3DDevice9::GetNPatchMode() { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetNPatchMode"); return gcpRendD3D->m_pActuald3dDevice->GetNPatchMode(); } HRESULT CMyDirect3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, %d)\n", "D3DDevice::DrawPrimitive", sD3DPT(PrimitiveType), StartVertex, PrimitiveCount); return gcpRendD3D->m_pActuald3dDevice->DrawPrimitive(PrimitiveType,StartVertex,PrimitiveCount); } HRESULT CMyDirect3DDevice9::DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, %d, %d, %d, %d)\n", "D3DDevice::DrawIndexedPrimitive", sD3DPT(PrimitiveType), BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount); return gcpRendD3D->m_pActuald3dDevice->DrawIndexedPrimitive(PrimitiveType,BaseVertexIndex,MinVertexIndex,NumVertices,startIndex,primCount); } HRESULT CMyDirect3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, 0x%x, %d)\n", "D3DDevice::DrawPrimitiveUP", sD3DPT(PrimitiveType), PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride); return gcpRendD3D->m_pActuald3dDevice->DrawPrimitiveUP(PrimitiveType,PrimitiveCount,pVertexStreamZeroData,VertexStreamZeroStride); } HRESULT CMyDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::DrawIndexedPrimitiveUP"); return gcpRendD3D->m_pActuald3dDevice->DrawIndexedPrimitiveUP(PrimitiveType,MinVertexIndex,NumVertices,PrimitiveCount, pIndexData,IndexDataFormat,pVertexStreamZeroData,VertexStreamZeroStride); } HRESULT CMyDirect3DDevice9::ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::ProcessVertices"); return gcpRendD3D->m_pActuald3dDevice->ProcessVertices(SrcStartIndex,DestIndex,VertexCount,pDestBuffer,pVertexDecl,Flags); } HRESULT CMyDirect3DDevice9::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateVertexDeclaration"); return gcpRendD3D->m_pActuald3dDevice->CreateVertexDeclaration(pVertexElements,ppDecl); } HRESULT CMyDirect3DDevice9::SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "D3DDevice::SetVertexDeclaration", pDecl); return gcpRendD3D->m_pActuald3dDevice->SetVertexDeclaration(pDecl); } HRESULT CMyDirect3DDevice9::GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetVertexDeclaration"); return gcpRendD3D->m_pActuald3dDevice->GetVertexDeclaration( ppDecl); } HRESULT CMyDirect3DDevice9::SetFVF(DWORD FVF) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "D3DDevice::SetFVF", sFVF(FVF)); return gcpRendD3D->m_pActuald3dDevice->SetFVF(FVF); } HRESULT CMyDirect3DDevice9::GetFVF(DWORD* pFVF) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetFVF"); return gcpRendD3D->m_pActuald3dDevice->GetFVF( pFVF); } HRESULT CMyDirect3DDevice9::CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateVertexShader"); return gcpRendD3D->m_pActuald3dDevice->CreateVertexShader(pFunction, ppShader); } HRESULT CMyDirect3DDevice9::SetVertexShader(IDirect3DVertexShader9* pShader) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "D3DDevice::SetVertexShader", pShader); return gcpRendD3D->m_pActuald3dDevice->SetVertexShader( pShader); } HRESULT CMyDirect3DDevice9::GetVertexShader(IDirect3DVertexShader9** ppShader) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetVertexShader"); return gcpRendD3D->m_pActuald3dDevice->GetVertexShader( ppShader); } HRESULT CMyDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d", "D3DDevice::SetVertexShaderConstantF", StartRegister); const float *v = pConstantData; for (int i=0; i<(int)Vector4fCount; i++) { gcpRendD3D->Logv(0, ", [%.3f, %.3f, %.3f, %.3f]", v[0], v[1], v[2], v[3]); v += 4; } gcpRendD3D->Logv(0, ", %d)\n", Vector4fCount); return gcpRendD3D->m_pActuald3dDevice->SetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount); } HRESULT CMyDirect3DDevice9::GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetVertexShaderConstantF"); return gcpRendD3D->m_pActuald3dDevice->GetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount); } HRESULT CMyDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetVertexShaderConstantI"); return gcpRendD3D->m_pActuald3dDevice->SetVertexShaderConstantI(StartRegister,pConstantData,Vector4iCount); } HRESULT CMyDirect3DDevice9::GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetVertexShaderConstantI"); return gcpRendD3D->m_pActuald3dDevice->GetVertexShaderConstantI(StartRegister,pConstantData,Vector4iCount); } HRESULT CMyDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetVertexShaderConstantB"); return gcpRendD3D->m_pActuald3dDevice->SetVertexShaderConstantB(StartRegister,pConstantData,BoolCount); } HRESULT CMyDirect3DDevice9::GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetVertexShaderConstantB"); return gcpRendD3D->m_pActuald3dDevice->GetVertexShaderConstantB(StartRegister,pConstantData,BoolCount); } HRESULT CMyDirect3DDevice9::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, 0x%x, %d, %d)\n", "D3DDevice::SetStreamSource", StreamNumber, pStreamData, OffsetInBytes, Stride); return gcpRendD3D->m_pActuald3dDevice->SetStreamSource(StreamNumber,pStreamData,OffsetInBytes,Stride); } HRESULT CMyDirect3DDevice9::GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetStreamSource"); return gcpRendD3D->m_pActuald3dDevice->GetStreamSource(StreamNumber, ppStreamData, OffsetInBytes, pStride); } HRESULT CMyDirect3DDevice9::SetStreamSourceFreq(UINT StreamNumber,UINT Divider) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d, 0x%x)\n", "D3DDevice::SetStreamSourceFreq", StreamNumber, Divider); return gcpRendD3D->m_pActuald3dDevice->SetStreamSourceFreq(StreamNumber,Divider); } HRESULT CMyDirect3DDevice9::GetStreamSourceFreq(UINT StreamNumber,UINT* Divider) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetStreamSourceFreq"); return gcpRendD3D->m_pActuald3dDevice->GetStreamSourceFreq(StreamNumber,Divider); } HRESULT CMyDirect3DDevice9::SetIndices(IDirect3DIndexBuffer9* pIndexData) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "D3DDevice::SetIndices", pIndexData); return gcpRendD3D->m_pActuald3dDevice->SetIndices( pIndexData); } HRESULT CMyDirect3DDevice9::GetIndices(IDirect3DIndexBuffer9** ppIndexData) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetIndices"); return gcpRendD3D->m_pActuald3dDevice->GetIndices( ppIndexData); } HRESULT CMyDirect3DDevice9::CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreatePixelShader"); return gcpRendD3D->m_pActuald3dDevice->CreatePixelShader(pFunction,ppShader); } HRESULT CMyDirect3DDevice9::SetPixelShader(IDirect3DPixelShader9* pShader) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "D3DDevice::SetPixelShader", pShader); return gcpRendD3D->m_pActuald3dDevice->SetPixelShader( pShader); } HRESULT CMyDirect3DDevice9::GetPixelShader(IDirect3DPixelShader9** ppShader) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "D3DDevice::GetPixelShader", ppShader); return gcpRendD3D->m_pActuald3dDevice->GetPixelShader( ppShader); } HRESULT CMyDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s (%d", "D3DDevice::SetPixelShaderConstantF", StartRegister); const float *v = pConstantData; for (int i=0; i<(int)Vector4fCount; i++) { gcpRendD3D->Logv(0, ", [%.3f, %.3f, %.3f, %.3f]", v[0], v[1], v[2], v[3]); v += 4; } gcpRendD3D->Logv(0, ", %d)\n", Vector4fCount); return gcpRendD3D->m_pActuald3dDevice->SetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount); } HRESULT CMyDirect3DDevice9::GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetPixelShaderConstantF"); return gcpRendD3D->m_pActuald3dDevice->GetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount); } HRESULT CMyDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetPixelShaderConstantI"); return gcpRendD3D->m_pActuald3dDevice->SetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount); } HRESULT CMyDirect3DDevice9::GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetPixelShaderConstantI"); return gcpRendD3D->m_pActuald3dDevice->GetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount); } HRESULT CMyDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::SetPixelShaderConstantB"); return gcpRendD3D->m_pActuald3dDevice->SetPixelShaderConstantB(StartRegister,pConstantData,BoolCount); } HRESULT CMyDirect3DDevice9::GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::GetPixelShaderConstantB"); return gcpRendD3D->m_pActuald3dDevice->GetPixelShaderConstantB(StartRegister,pConstantData,BoolCount); } HRESULT CMyDirect3DDevice9::DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::DrawRectPatch"); return gcpRendD3D->m_pActuald3dDevice->DrawRectPatch(Handle,pNumSegs,pRectPatchInfo); } HRESULT CMyDirect3DDevice9::DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::DrawTriPatch"); return gcpRendD3D->m_pActuald3dDevice->DrawTriPatch(Handle,pNumSegs,pTriPatchInfo); } HRESULT CMyDirect3DDevice9::DeletePatch(UINT Handle) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::DeletePatch"); return gcpRendD3D->m_pActuald3dDevice->DeletePatch(Handle); } HRESULT CMyDirect3DDevice9::CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery) { gcpRendD3D->Logv(SRendItem::m_RecurseLevel, "%s\n", "D3DDevice::CreateQuery"); return gcpRendD3D->m_pActuald3dDevice->CreateQuery(Type, ppQuery); } //============================================================================================== void CD3D9Renderer::SetLogFuncs(bool set) { static bool sSet = 0; if (set == sSet) return; sSet = set; if (set) { m_pActuald3dDevice = m_pd3dDevice; if (!m_pMyd3dDevice) m_pMyd3dDevice = new CMyDirect3DDevice9; m_pd3dDevice = m_pMyd3dDevice; } else { m_pd3dDevice = m_pActuald3dDevice; } }