diff options
Diffstat (limited to 'materialsystem/shaderapidx9/stubd3ddevice.h')
| -rw-r--r-- | materialsystem/shaderapidx9/stubd3ddevice.h | 809 |
1 files changed, 809 insertions, 0 deletions
diff --git a/materialsystem/shaderapidx9/stubd3ddevice.h b/materialsystem/shaderapidx9/stubd3ddevice.h new file mode 100644 index 0000000..a97f015 --- /dev/null +++ b/materialsystem/shaderapidx9/stubd3ddevice.h @@ -0,0 +1,809 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef STUBD3DDEVICE_H +#define STUBD3DDEVICE_H +#ifdef _WIN32 +#pragma once +#endif + +#ifdef STUBD3D + +#include "locald3dtypes.h" +#include "filesystem.h" + +#ifdef USE_FOPEN +#include <stdio.h> +#define FPRINTF fprintf +#else +#define FPRINTF s_pFileSystem->FPrintf +#endif + +#ifdef USE_FOPEN + +static FILE *s_FileHandle; + +#else + +static IFileSystem *s_pFileSystem; +static FileHandle_t s_FileHandle; + +#endif + + + +class CStubD3DTexture : public IDirect3DTexture8 +{ +private: + IDirect3DTexture8 *m_pTexture; + IDirect3DDevice8 *m_pDevice; + +public: + CStubD3DTexture( IDirect3DTexture8 *pTexture, IDirect3DDevice8 *pDevice ) + { + m_pTexture = pTexture; + m_pDevice = pDevice; + } + + /*** IUnknown methods ***/ + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::QueryInterface\n" ); + return m_pTexture->QueryInterface( riid, ppvObj ); + } + + ULONG __stdcall AddRef() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::AddRef\n" ); + return m_pTexture->AddRef(); + } + + ULONG __stdcall Release() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::Release\n" ); + return m_pTexture->Release(); + } + + /*** IDirect3DBaseTexture8 methods ***/ + HRESULT __stdcall GetDevice( IDirect3DDevice8** ppDevice ) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetDevice\n" ); +#if 0 + *ppDevice = m_pDevice; + return D3D_OK; +#else + return m_pTexture->GetDevice( ppDevice ); +#endif + } + + HRESULT __stdcall SetPrivateData( REFGUID refguid,CONST void* pData,DWORD SizeOfData,DWORD Flags) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::SetPrivateData\n" ); + return m_pTexture->SetPrivateData( refguid, pData, SizeOfData, Flags ); + } + + HRESULT __stdcall GetPrivateData( REFGUID refguid,void* pData,DWORD* pSizeOfData ) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetPrivateData\n" ); + return m_pTexture->GetPrivateData( refguid, pData, pSizeOfData ); + } + + HRESULT __stdcall FreePrivateData( REFGUID refguid ) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetPrivateData\n" ); + return m_pTexture->FreePrivateData( refguid ); + } + + DWORD __stdcall SetPriority( DWORD PriorityNew ) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::SetPriority\n" ); + return m_pTexture->SetPriority( PriorityNew ); + } + + DWORD __stdcall GetPriority() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetPriority\n" ); + return m_pTexture->GetPriority(); + } + + void __stdcall PreLoad() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::PreLoad\n" ); + m_pTexture->PreLoad(); + } + + D3DRESOURCETYPE __stdcall GetType() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetType\n" ); + return m_pTexture->GetType(); + } + + DWORD __stdcall SetLOD( DWORD LODNew ) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::SetLOD\n" ); + return m_pTexture->SetLOD( LODNew ); + } + + DWORD __stdcall GetLOD() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetLOD\n" ); + return m_pTexture->GetLOD(); + } + + DWORD __stdcall GetLevelCount() + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetLevelCount\n" ); + return m_pTexture->GetLevelCount(); + } + + HRESULT __stdcall GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetLevelCount\n" ); + return m_pTexture->GetLevelDesc( Level, pDesc ); + } + + HRESULT __stdcall GetSurfaceLevel(UINT Level,IDirect3DSurface8** ppSurfaceLevel) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::GetSurfaceLevel\n" ); + return m_pTexture->GetSurfaceLevel( Level, ppSurfaceLevel ); + } + + HRESULT __stdcall LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::LockRect\n" ); + return m_pTexture->LockRect( Level, pLockedRect, pRect, Flags ); + } + + HRESULT __stdcall UnlockRect(UINT Level) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::UnlockRect\n" ); + return m_pTexture->UnlockRect( Level ); + } + + HRESULT __stdcall AddDirtyRect( CONST RECT* pDirtyRect ) + { + FPRINTF( s_FileHandle, "IDirect3DTexture8::AddDirtyRect\n" ); + return m_pTexture->AddDirtyRect( pDirtyRect ); + } +}; + +class CStubD3DDevice : public IDirect3DDevice8 +{ +public: + CStubD3DDevice( IDirect3DDevice8 *pD3DDevice, IFileSystem *pFileSystem ) + { + Assert( pD3DDevice ); + m_pD3DDevice = pD3DDevice; +#ifdef USE_FOPEN + s_FileHandle = fopen( "stubd3d.txt", "w" ); +#else + Assert( pFileSystem ); + s_pFileSystem = pFileSystem; + s_FileHandle = pFileSystem->Open( "stubd3d.txt", "w" ); +#endif + } + + ~CStubD3DDevice() + { +#ifdef USE_FOPEN + fclose( s_FileHandle ); +#else + s_pFileSystem->Close( s_FileHandle ); +#endif + } + +private: + IDirect3DDevice8 *m_pD3DDevice; + +public: + /*** IUnknown methods ***/ + HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj) + { + FPRINTF( s_FileHandle, "QueryInterface\n" ); + return m_pD3DDevice->QueryInterface( riid, ppvObj ); + } + + ULONG __stdcall AddRef() + { + FPRINTF( s_FileHandle, "AddRef\n" ); + return m_pD3DDevice->AddRef(); + } + + ULONG __stdcall Release() + { + FPRINTF( s_FileHandle, "Release\n" ); + return m_pD3DDevice->Release(); + delete this; + } + + /*** IDirect3DDevice8 methods ***/ + HRESULT __stdcall TestCooperativeLevel() + { + FPRINTF( s_FileHandle, "TestCooperativeLevel\n" ); + return m_pD3DDevice->TestCooperativeLevel(); + } + + UINT __stdcall GetAvailableTextureMem() + { + FPRINTF( s_FileHandle, "GetAvailableTextureMem\n" ); + return m_pD3DDevice->GetAvailableTextureMem(); + } + + HRESULT __stdcall ResourceManagerDiscardBytes(DWORD Bytes) + { + FPRINTF( s_FileHandle, "ResourceManagerDiscardBytes\n" ); + return m_pD3DDevice->ResourceManagerDiscardBytes( Bytes ); + } + + HRESULT __stdcall GetDirect3D(IDirect3D8** ppD3D8) + { + FPRINTF( s_FileHandle, "GetDirect3D\n" ); + return m_pD3DDevice->GetDirect3D( ppD3D8 ); + } + + HRESULT __stdcall GetDeviceCaps(D3DCAPS8* pCaps) + { + FPRINTF( s_FileHandle, "GetDeviceCaps\n" ); + return m_pD3DDevice->GetDeviceCaps( pCaps ); + } + + HRESULT __stdcall GetDisplayMode(D3DDISPLAYMODE* pMode) + { + FPRINTF( s_FileHandle, "GetDisplayMode\n" ); + return m_pD3DDevice->GetDisplayMode( pMode ); + } + + HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) + { + FPRINTF( s_FileHandle, "GetCreationParameters\n" ); + return m_pD3DDevice->GetCreationParameters( pParameters ); + } + + HRESULT __stdcall SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface8* pCursorBitmap) + { + FPRINTF( s_FileHandle, "SetCursorProperties\n" ); + return m_pD3DDevice->SetCursorProperties( XHotSpot, YHotSpot, pCursorBitmap ); + } + + void __stdcall SetCursorPosition(UINT XScreenSpace,UINT YScreenSpace,DWORD Flags) + { + FPRINTF( s_FileHandle, "SetCursorPosition\n" ); + m_pD3DDevice->SetCursorPosition( XScreenSpace, YScreenSpace, Flags ); + } + + BOOL __stdcall ShowCursor(BOOL bShow) + { + FPRINTF( s_FileHandle, "ShowCursor\n" ); + return m_pD3DDevice->ShowCursor( bShow ); + } + + HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain8** pSwapChain) + { + FPRINTF( s_FileHandle, "CreateAdditionalSwapChain\n" ); + return m_pD3DDevice->CreateAdditionalSwapChain( pPresentationParameters, pSwapChain ); + } + + HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters) + { + FPRINTF( s_FileHandle, "Reset\n" ); + return m_pD3DDevice->Reset( pPresentationParameters ); + } + + HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion) + { + FPRINTF( s_FileHandle, "Present\n" ); + return m_pD3DDevice->Present( pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion ); + } + + HRESULT __stdcall GetBackBuffer(UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer) + { + FPRINTF( s_FileHandle, "GetBackBuffer\n" ); + return m_pD3DDevice->GetBackBuffer( BackBuffer, Type, ppBackBuffer ); + } + + HRESULT __stdcall GetRasterStatus(D3DRASTER_STATUS* pRasterStatus) + { + FPRINTF( s_FileHandle, "GetRasterStatus\n" ); + return m_pD3DDevice->GetRasterStatus( pRasterStatus ); + } + + void __stdcall SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp) + { + FPRINTF( s_FileHandle, "SetGammaRamp\n" ); + m_pD3DDevice->SetGammaRamp( Flags, pRamp ); + } + + void __stdcall GetGammaRamp(D3DGAMMARAMP* pRamp) + { + FPRINTF( s_FileHandle, "GetGammaRamp\n" ); + m_pD3DDevice->GetGammaRamp( pRamp ); + } + + HRESULT __stdcall CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture) + { + FPRINTF( s_FileHandle, "CreateTexture\n" ); +#if 0 + HRESULT ret = m_pD3DDevice->CreateTexture( Width, Height, Levels, Usage, Format, Pool, ppTexture ); + if( ret == D3D_OK ) + { + *ppTexture = new CStubD3DTexture( *ppTexture, this ); + return ret; + } + else + { + return ret; + } +#else + return m_pD3DDevice->CreateTexture( Width, Height, Levels, Usage, Format, Pool, ppTexture ); +#endif + } + + HRESULT __stdcall CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture) + { + FPRINTF( s_FileHandle, "CreateVolumeTexture\n" ); + return m_pD3DDevice->CreateVolumeTexture( Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture ); + } + + HRESULT __stdcall CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture) + { + FPRINTF( s_FileHandle, "CreateCubeTexture\n" ); + return m_pD3DDevice->CreateCubeTexture( EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture ); + } + + HRESULT __stdcall CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer) + { + FPRINTF( s_FileHandle, "CreateVertexBuffer\n" ); + return m_pD3DDevice->CreateVertexBuffer( Length, Usage, FVF, Pool, ppVertexBuffer ); + } + + HRESULT __stdcall CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer) + { + FPRINTF( s_FileHandle, "CreateIndexBuffer\n" ); + return m_pD3DDevice->CreateIndexBuffer( Length, Usage, Format, Pool, ppIndexBuffer ); + } + + HRESULT __stdcall CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface) + { + FPRINTF( s_FileHandle, "CreateRenderTarget\n" ); + return m_pD3DDevice->CreateRenderTarget( Width, Height, Format, MultiSample, Lockable, ppSurface ); + } + + HRESULT __stdcall CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface) + { + FPRINTF( s_FileHandle, "CreateDepthStencilSurface\n" ); + return m_pD3DDevice->CreateDepthStencilSurface( Width, Height, Format, MultiSample, ppSurface ); + } + + HRESULT __stdcall CreateImageSurface(UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface) + { + FPRINTF( s_FileHandle, "CreateImageSurface\n" ); + return m_pD3DDevice->CreateImageSurface( Width, Height, Format, ppSurface ); + } + + HRESULT __stdcall CopyRects(IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray) + { + FPRINTF( s_FileHandle, "CopyRects\n" ); + return m_pD3DDevice->CopyRects( pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray ); + } + + HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture) + { + FPRINTF( s_FileHandle, "UpdateTexture\n" ); + return m_pD3DDevice->UpdateTexture( pSourceTexture, pDestinationTexture ); + } + + HRESULT __stdcall GetFrontBuffer(IDirect3DSurface8* pDestSurface) + { + FPRINTF( s_FileHandle, "GetFrontBuffer\n" ); + return m_pD3DDevice->GetFrontBuffer( pDestSurface ); + } + + HRESULT __stdcall SetRenderTarget(IDirect3DSurface8* pRenderTarget,IDirect3DSurface8* pNewZStencil) + { + FPRINTF( s_FileHandle, "SetRenderTarget\n" ); + return m_pD3DDevice->SetRenderTarget( pRenderTarget, pNewZStencil ); + } + + HRESULT __stdcall GetRenderTarget(IDirect3DSurface8** ppRenderTarget) + { + FPRINTF( s_FileHandle, "GetRenderTarget\n" ); + return m_pD3DDevice->GetRenderTarget( ppRenderTarget ); + } + + HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface8** ppZStencilSurface) + { + FPRINTF( s_FileHandle, "GetDepthStencilSurface\n" ); + return m_pD3DDevice->GetDepthStencilSurface( ppZStencilSurface ); + } + + HRESULT __stdcall BeginScene( void ) + { + FPRINTF( s_FileHandle, "BeginScene\n" ); + return m_pD3DDevice->BeginScene(); + } + + HRESULT __stdcall EndScene() + { + FPRINTF( s_FileHandle, "EndScene\n" ); + return m_pD3DDevice->EndScene(); + } + + HRESULT __stdcall Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) + { + FPRINTF( s_FileHandle, "Clear\n" ); + return m_pD3DDevice->Clear( Count, pRects, Flags, Color, Z, Stencil ); + } + + HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix) + { + FPRINTF( s_FileHandle, "SetTransform\n" ); + return m_pD3DDevice->SetTransform( State, pMatrix ); + } + + HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix) + { + FPRINTF( s_FileHandle, "GetTransform\n" ); + return m_pD3DDevice->GetTransform( State, pMatrix ); + } + + HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE transformState,CONST D3DMATRIX* pMatrix) + { + FPRINTF( s_FileHandle, "MultiplyTransform\n" ); + return m_pD3DDevice->MultiplyTransform( transformState, pMatrix ); + } + + HRESULT __stdcall SetViewport(CONST D3DVIEWPORT8* pViewport) + { + FPRINTF( s_FileHandle, "SetViewport\n" ); + return m_pD3DDevice->SetViewport( pViewport ); + } + + HRESULT __stdcall GetViewport(D3DVIEWPORT8* pViewport) + { + FPRINTF( s_FileHandle, "GetViewport\n" ); + return m_pD3DDevice->GetViewport( pViewport ); + } + + HRESULT __stdcall SetMaterial(CONST D3DMATERIAL8* pMaterial) + { + FPRINTF( s_FileHandle, "SetMaterial\n" ); + return m_pD3DDevice->SetMaterial( pMaterial ); + } + + HRESULT __stdcall GetMaterial(D3DMATERIAL8* pMaterial) + { + FPRINTF( s_FileHandle, "GetMaterial\n" ); + return m_pD3DDevice->GetMaterial( pMaterial ); + } + + HRESULT __stdcall SetLight(DWORD Index,CONST D3DLIGHT8* pLight) + { + FPRINTF( s_FileHandle, "SetLight\n" ); + return m_pD3DDevice->SetLight( Index, pLight ); + } + + HRESULT __stdcall GetLight(DWORD Index,D3DLIGHT8* pLight) + { + FPRINTF( s_FileHandle, "GetLight\n" ); + return m_pD3DDevice->GetLight( Index, pLight ); + } + + HRESULT __stdcall LightEnable(DWORD Index,BOOL Enable) + { + FPRINTF( s_FileHandle, "LightEnable\n" ); + return m_pD3DDevice->LightEnable( Index, Enable ); + } + + HRESULT __stdcall GetLightEnable(DWORD Index,BOOL* pEnable) + { + FPRINTF( s_FileHandle, "GetLightEnable\n" ); + return m_pD3DDevice->GetLightEnable( Index, pEnable ); + } + + HRESULT __stdcall SetClipPlane(DWORD Index,CONST float* pPlane) + { + FPRINTF( s_FileHandle, "SetClipPlane\n" ); + return m_pD3DDevice->SetClipPlane( Index, pPlane ); + } + + HRESULT __stdcall GetClipPlane(DWORD Index,float* pPlane) + { + FPRINTF( s_FileHandle, "GetClipPlane\n" ); + return m_pD3DDevice->GetClipPlane( Index, pPlane ); + } + + HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State,DWORD Value) + { + FPRINTF( s_FileHandle, "SetRenderState\n" ); + return m_pD3DDevice->SetRenderState( State, Value ); + } + + HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue) + { + FPRINTF( s_FileHandle, "GetRenderState\n" ); + return m_pD3DDevice->GetRenderState( State, pValue ); + } + + HRESULT __stdcall BeginStateBlock(void) + { + FPRINTF( s_FileHandle, "BeginStateBlock\n" ); + return m_pD3DDevice->BeginStateBlock(); + } + + HRESULT __stdcall EndStateBlock(DWORD* pToken) + { + FPRINTF( s_FileHandle, "EndStateBlock\n" ); + return m_pD3DDevice->EndStateBlock( pToken ); + } + + HRESULT __stdcall ApplyStateBlock(DWORD Token) + { + FPRINTF( s_FileHandle, "ApplyStateBlock\n" ); + return m_pD3DDevice->ApplyStateBlock( Token ); + } + + HRESULT __stdcall CaptureStateBlock(DWORD Token) + { + FPRINTF( s_FileHandle, "CaptureStateBlock\n" ); + return m_pD3DDevice->CaptureStateBlock( Token ); + } + + HRESULT __stdcall DeleteStateBlock(DWORD Token) + { + FPRINTF( s_FileHandle, "DeleteStateBlock\n" ); + return m_pD3DDevice->DeleteStateBlock( Token ); + } + + HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type,DWORD* pToken) + { + FPRINTF( s_FileHandle, "CreateStateBlock\n" ); + return m_pD3DDevice->CreateStateBlock( Type, pToken ); + } + + HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS8* pClipStatus) + { + FPRINTF( s_FileHandle, "SetClipStatus\n" ); + return m_pD3DDevice->SetClipStatus( pClipStatus ); + } + + HRESULT __stdcall GetClipStatus(D3DCLIPSTATUS8* pClipStatus) + { + FPRINTF( s_FileHandle, "GetClipStatus\n" ); + return m_pD3DDevice->GetClipStatus( pClipStatus ); + } + + HRESULT __stdcall GetTexture(DWORD Stage,IDirect3DBaseTexture8** ppTexture) + { + FPRINTF( s_FileHandle, "GetTexture\n" ); + return m_pD3DDevice->GetTexture( Stage, ppTexture ); + } + + HRESULT __stdcall SetTexture(DWORD Stage,IDirect3DBaseTexture8* pTexture) + { + FPRINTF( s_FileHandle, "SetTexture\n" ); + return m_pD3DDevice->SetTexture( Stage, pTexture ); + } + + HRESULT __stdcall GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue) + { + FPRINTF( s_FileHandle, "GetTextureStageState\n" ); + return m_pD3DDevice->GetTextureStageState( Stage, Type, pValue ); + } + + HRESULT __stdcall SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value) + { + FPRINTF( s_FileHandle, "SetTextureStageState\n" ); + return m_pD3DDevice->SetTextureStageState( Stage, Type, Value ); + } + + HRESULT __stdcall ValidateDevice(DWORD* pNumPasses) + { + FPRINTF( s_FileHandle, "ValidateDevice\n" ); +#if 0 + return m_pD3DDevice->ValidateDevice( pNumPasses ); +#else + return D3D_OK; +#endif + } + + HRESULT __stdcall GetInfo(DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize) + { + FPRINTF( s_FileHandle, "GetInfo\n" ); + return m_pD3DDevice->GetInfo( DevInfoID, pDevInfoStruct, DevInfoStructSize ); + } + + HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries) + { + FPRINTF( s_FileHandle, "SetPaletteEntries\n" ); + return m_pD3DDevice->SetPaletteEntries( PaletteNumber, pEntries ); + } + + HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries) + { + FPRINTF( s_FileHandle, "GetPaletteEntries\n" ); + return m_pD3DDevice->GetPaletteEntries( PaletteNumber, pEntries ); + } + + HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber) + { + FPRINTF( s_FileHandle, "SetCurrentTexturePalette\n" ); + return m_pD3DDevice->SetCurrentTexturePalette( PaletteNumber ); + } + + HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber) + { + FPRINTF( s_FileHandle, "GetCurrentTexturePalette\n" ); + return m_pD3DDevice->GetCurrentTexturePalette( PaletteNumber ); + } + + HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount) + { + FPRINTF( s_FileHandle, "DrawPrimitive\n" ); + return m_pD3DDevice->DrawPrimitive( PrimitiveType, StartVertex, PrimitiveCount ); + } + + HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE primitiveType,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount) + { + FPRINTF( s_FileHandle, "DrawIndexedPrimitive\n" ); + return m_pD3DDevice->DrawIndexedPrimitive( primitiveType,minIndex,NumVertices,startIndex,primCount ); + } + + HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) + { + FPRINTF( s_FileHandle, "DrawPrimitiveUP\n" ); + return m_pD3DDevice->DrawPrimitiveUP( PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride ); + } + + HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride) + { + FPRINTF( s_FileHandle, "DrawIndexedPrimitiveUP\n" ); + return m_pD3DDevice->DrawIndexedPrimitiveUP( PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat,pVertexStreamZeroData, VertexStreamZeroStride ); + } + + HRESULT __stdcall ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags) + { + FPRINTF( s_FileHandle, "ProcessVertices\n" ); + return m_pD3DDevice->ProcessVertices( SrcStartIndex, DestIndex, VertexCount, pDestBuffer, Flags ); + } + + HRESULT __stdcall CreateVertexShader(CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage) + { + FPRINTF( s_FileHandle, "CreateVertexShader\n" ); + return m_pD3DDevice->CreateVertexShader( pDeclaration, pFunction, pHandle, Usage ); + } + + HRESULT __stdcall SetVertexShader(DWORD Handle) + { + FPRINTF( s_FileHandle, "SetVertexShader\n" ); + return m_pD3DDevice->SetVertexShader( Handle ); + } + + HRESULT __stdcall GetVertexShader(DWORD* pHandle) + { + FPRINTF( s_FileHandle, "GetVertexShader\n" ); + return m_pD3DDevice->GetVertexShader( pHandle ); + } + + HRESULT __stdcall DeleteVertexShader(DWORD Handle) + { + FPRINTF( s_FileHandle, "DeleteVertexShader\n" ); + return m_pD3DDevice->DeleteVertexShader( Handle ); + } + + HRESULT __stdcall SetVertexShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount) + { + FPRINTF( s_FileHandle, "SetVertexShaderConstant\n" ); + return m_pD3DDevice->SetVertexShaderConstant( Register, pConstantData, ConstantCount ); + } + + HRESULT __stdcall GetVertexShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount) + { + FPRINTF( s_FileHandle, "GetVertexShaderConstant\n" ); + return m_pD3DDevice->GetVertexShaderConstant( Register, pConstantData, ConstantCount ); + } + + HRESULT __stdcall GetVertexShaderDeclaration(DWORD Handle,void* pData,DWORD* pSizeOfData) + { + FPRINTF( s_FileHandle, "GetVertexShaderDeclaration\n" ); + return m_pD3DDevice->GetVertexShaderDeclaration( Handle, pData, pSizeOfData ); + } + + HRESULT __stdcall GetVertexShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData) + { + FPRINTF( s_FileHandle, "GetVertexShaderFunction\n" ); + return m_pD3DDevice->GetVertexShaderFunction( Handle, pData, pSizeOfData ); + } + + HRESULT __stdcall SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride) + { + FPRINTF( s_FileHandle, "SetStreamSource\n" ); + return m_pD3DDevice->SetStreamSource( StreamNumber, pStreamData, Stride ); + } + + HRESULT __stdcall GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride) + { + FPRINTF( s_FileHandle, "GetStreamSource\n" ); + return m_pD3DDevice->GetStreamSource( StreamNumber, ppStreamData, pStride ); + } + + HRESULT __stdcall SetIndices(IDirect3DIndexBuffer8* pIndexData,UINT BaseVertexIndex) + { + FPRINTF( s_FileHandle, "SetIndices\n" ); + return m_pD3DDevice->SetIndices( pIndexData, BaseVertexIndex ); + } + + HRESULT __stdcall GetIndices(IDirect3DIndexBuffer8** ppIndexData,UINT* pBaseVertexIndex) + { + FPRINTF( s_FileHandle, "GetIndices\n" ); + return m_pD3DDevice->GetIndices( ppIndexData, pBaseVertexIndex ); + } + + HRESULT __stdcall CreatePixelShader(CONST DWORD* pFunction,DWORD* pHandle) + { + FPRINTF( s_FileHandle, "CreatePixelShader\n" ); + return m_pD3DDevice->CreatePixelShader( pFunction, pHandle ); + } + + HRESULT __stdcall SetPixelShader(DWORD Handle) + { + FPRINTF( s_FileHandle, "SetPixelShader\n" ); + return m_pD3DDevice->SetPixelShader( Handle ); + } + + HRESULT __stdcall GetPixelShader(DWORD* pHandle) + { + FPRINTF( s_FileHandle, "GetPixelShader\n" ); + return m_pD3DDevice->GetPixelShader( pHandle ); + } + + HRESULT __stdcall DeletePixelShader(DWORD Handle) + { + FPRINTF( s_FileHandle, "DeletePixelShader\n" ); + return m_pD3DDevice->DeletePixelShader( Handle ); + } + + HRESULT __stdcall SetPixelShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount) + { + FPRINTF( s_FileHandle, "SetPixelShaderConstant\n" ); + return m_pD3DDevice->SetPixelShaderConstant( Register, pConstantData, ConstantCount ); + } + + HRESULT __stdcall GetPixelShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount) + { + FPRINTF( s_FileHandle, "GetPixelShaderConstant\n" ); + return m_pD3DDevice->GetPixelShaderConstant( Register, pConstantData, ConstantCount ); + } + + HRESULT __stdcall GetPixelShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData) + { + FPRINTF( s_FileHandle, "GetPixelShaderFunction\n" ); + return m_pD3DDevice->GetPixelShaderFunction( Handle, pData, pSizeOfData ); + } + + HRESULT __stdcall DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo) + { + FPRINTF( s_FileHandle, "DrawRectPatch\n" ); + return m_pD3DDevice->DrawRectPatch( Handle, pNumSegs, pRectPatchInfo ); + } + + HRESULT __stdcall DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo) + { + FPRINTF( s_FileHandle, "DrawTriPatch\n" ); + return m_pD3DDevice->DrawTriPatch( Handle, pNumSegs, pTriPatchInfo ); + } + + HRESULT __stdcall DeletePatch(UINT Handle) + { + FPRINTF( s_FileHandle, "DeletePatch\n" ); + return m_pD3DDevice->DeletePatch( Handle ); + } +}; + +#endif // STUBD3D + +#endif // STUBD3DDEVICE_H + |