Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

810 lines
25 KiB

5 years ago
//========= 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