Direct3D Interface

 
class MineD3D : public IDirect3D9
{
private:
 IDirect3D9* Direct3D;
public:
 MineD3D(IDirect3D9* Direct3D9)
 {
  Direct3D=Direct3D9;
 }
 HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj)
 {
  return Direct3D->QueryInterface(riid,ppvObj);
 }
 ULONG __stdcall AddRef(void)
 {
  return Direct3D->AddRef();
 }
 ULONG __stdcall Release(void)
 {
  return Direct3D->Release();
 }
 HRESULT __stdcall RegisterSoftwareDevice(void* pInitializeFunction)
 {
  return Direct3D->RegisterSoftwareDevice(pInitializeFunction);
 }
 UINT __stdcall GetAdapterCount(void)
 {
  return Direct3D->GetAdapterCount();
 }
 HRESULT __stdcall GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier)
 {
  return Direct3D->GetAdapterIdentifier(Adapter,Flags,pIdentifier);
 }
 UINT __stdcall GetAdapterModeCount(UINT Adapter,D3DFORMAT Format)
 {
  return Direct3D->GetAdapterModeCount(Adapter,Format);
 }
 HRESULT __stdcall EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode)
 {
  return Direct3D->EnumAdapterModes(Adapter,Format,Mode,pMode);
 }
 HRESULT __stdcall GetAdapterDisplayMode(UINT Adapter,D3DDISPLAYMODE* pMode)
 {
  return Direct3D->GetAdapterDisplayMode(Adapter,pMode);
 }
 HRESULT __stdcall CheckDeviceType(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed)
 {
  return Direct3D->CheckDeviceType(Adapter,DevType,AdapterFormat,BackBufferFormat,bWindowed);
 }
 HRESULT __stdcall CheckDeviceFormat(UINT Adapter,D3DDEVTYPE Type,D3DFORMAT Format,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat)
 {
  return Direct3D->CheckDeviceFormat(Adapter,Type,Format,Usage,RType,CheckFormat);
 }
 HRESULT __stdcall CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE Type,D3DFORMAT Format,BOOL Window,D3DMULTISAMPLE_TYPE Multi,DWORD* Levels) 
 {
  return Direct3D->CheckDeviceMultiSampleType(Adapter,Type,Format,Window,Multi,Levels);
 }
 HRESULT __stdcall CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE Type,D3DFORMAT Format,D3DFORMAT D3DFormat,D3DFORMAT Depth)
 {
  return Direct3D->CheckDepthStencilMatch(Adapter,Type,Format,Format,Depth);
 }
 HRESULT __stdcall CheckDeviceFormatConversion(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat)
 {
  return Direct3D->CheckDeviceFormatConversion(Adapter,DeviceType,SourceFormat,TargetFormat);
 }
 HRESULT __stdcall GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps)
 {
  return Direct3D->GetDeviceCaps(Adapter,DeviceType,pCaps);
 }
 HMONITOR __stdcall GetAdapterMonitor(UINT Adapter)
 {
  return Direct3D->GetAdapterMonitor(Adapter);
 }
 HRESULT __stdcall CreateDevice(UINT Adapter,D3DDEVTYPE Type,HWND Window,DWORD Flags,D3DPRESENT_PARAMETERS* Pres,IDirect3DDevice9** Device);

 IDirect3DDevice9* Direct3DDevice;
 IDirect3DDevice9* DeviceTemp;
};

class MineDevice : public IDirect3DDevice9 
{
private:
 IDirect3DDevice9* Device3D;
public:
 MineDevice(IDirect3DDevice9* Device9)
 {
  Device3D=Device9;
 }
 HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObj)
 {
  return Device3D->QueryInterface(riid,ppvObj);
 }
 ULONG __stdcall AddRef(void)
 {
  return Device3D->AddRef();
 }
 ULONG __stdcall Release(void)
 {
  return Device3D->Release();
 }
 HRESULT __stdcall TestCooperativeLevel(void)
 {
  return Device3D->TestCooperativeLevel();
 }
 UINT __stdcall GetAvailableTextureMem(void) 
 {
  return Device3D->GetAvailableTextureMem();
 }
 HRESULT __stdcall EvictManagedResources(void) 
 {
  return Device3D->EvictManagedResources();
 }
 HRESULT __stdcall GetDirect3D(IDirect3D9** ppD3D9) 
 {
  return Device3D->GetDirect3D(ppD3D9);
 }
 HRESULT __stdcall GetDeviceCaps(D3DCAPS9* pCaps)
 {
  return Device3D->GetDeviceCaps(pCaps);
 }
 HRESULT __stdcall GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode)
 {
  return Device3D->GetDisplayMode(iSwapChain,pMode);
 }
 HRESULT __stdcall GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters)
 {
  return Device3D->GetCreationParameters(pParameters);
 }
 HRESULT __stdcall SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9* pCursorBitmap)
 {
  return Device3D->SetCursorProperties(XHotSpot,YHotSpot,pCursorBitmap);
 }
 void __stdcall SetCursorPosition(int X,int Y,DWORD Flags)
 {
  return Device3D->SetCursorPosition(X,Y,Flags);
 }
 BOOL __stdcall ShowCursor(BOOL bShow) 
 {
  return Device3D->ShowCursor(bShow);
 }
 HRESULT __stdcall CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9** pSwapChain)
 {
  return Device3D->CreateAdditionalSwapChain(pPresentationParameters,pSwapChain);
 }
 HRESULT __stdcall GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9** pSwapChain)
 {
  return Device3D->GetSwapChain(iSwapChain,pSwapChain);
 }
 UINT __stdcall GetNumberOfSwapChains(void)
 {
  return Device3D->GetNumberOfSwapChains();
 }
 HRESULT __stdcall Reset(D3DPRESENT_PARAMETERS* pPresentationParameters)
 {
  return Device3D->Reset(pPresentationParameters);
 }
 HRESULT __stdcall Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
 {
  return Device3D->Present(pSourceRect,pDestRect,hDestWindowOverride,pDirtyRegion);
 }
 HRESULT __stdcall GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer)
 {
  return Device3D->GetBackBuffer(iSwapChain,iBackBuffer,Type,ppBackBuffer);
 }
 HRESULT __stdcall GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus)
 {
  return Device3D->GetRasterStatus(iSwapChain,pRasterStatus);
 }
 HRESULT __stdcall SetDialogBoxMode(BOOL bEnableDialogs)
 {
  return Device3D->SetDialogBoxMode(bEnableDialogs);
 }
 void __stdcall SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp)
 {
  return Device3D->SetGammaRamp(iSwapChain,Flags,pRamp);
 }
 void __stdcall GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp)
 {
  return Device3D->GetGammaRamp(iSwapChain,pRamp);
 }
 HRESULT __stdcall CreateTexture(UINT W,UINT H,UINT L,DWORD U,D3DFORMAT F,D3DPOOL P,IDirect3DTexture9** T,HANDLE* S) 
 {
  return Device3D->CreateTexture(W,H,L,U,F,P,T,S);
 }
 HRESULT __stdcall CreateVolumeTexture(UINT W,UINT H,UINT D,UINT L,DWORD U,D3DFORMAT F,D3DPOOL P,IDirect3DVolumeTexture9** V,HANDLE* S)
 {
  return Device3D->CreateVolumeTexture(W,H,D,L,U,F,P,V,S);
 }
 HRESULT __stdcall CreateCubeTexture(UINT E,UINT L,DWORD U,D3DFORMAT F,D3DPOOL P,IDirect3DCubeTexture9** C,HANDLE* S)
 {
  return Device3D->CreateCubeTexture(E,L,U,F,P,C,S);
 }
 HRESULT __stdcall CreateVertexBuffer(UINT L,DWORD U,DWORD F,D3DPOOL P,IDirect3DVertexBuffer9** V,HANDLE* S)
 {
  return Device3D->CreateVertexBuffer(L,U,F,P,V,S);
 }
 HRESULT __stdcall CreateIndexBuffer(UINT L,DWORD U,D3DFORMAT F,D3DPOOL P,IDirect3DIndexBuffer9** I,HANDLE* S)
 {
  return Device3D->CreateIndexBuffer(L,U,F,P,I,S);
 }
 HRESULT __stdcall CreateRenderTarget(UINT W,UINT Y,D3DFORMAT F,D3DMULTISAMPLE_TYPE M,DWORD Q,BOOL L,IDirect3DSurface9** S,HANDLE* H)
 {
  return Device3D->CreateRenderTarget(W,Y,F,M,Q,L,S,H);
 }
 HRESULT __stdcall CreateDepthStencilSurface(UINT W,UINT H,D3DFORMAT F,D3DMULTISAMPLE_TYPE M,DWORD Q,BOOL D,IDirect3DSurface9** I,HANDLE* S)
 {
  return Device3D->CreateDepthStencilSurface(W,H,F,M,Q,D,I,S);
 }
 HRESULT __stdcall UpdateSurface(IDirect3DSurface9* S,CONST RECT* R,IDirect3DSurface9* D,CONST POINT* P)
 {
  return Device3D->UpdateSurface(S,R,D,P);
 }
 HRESULT __stdcall UpdateTexture(IDirect3DBaseTexture9* pSourceTexture,IDirect3DBaseTexture9* pDestinationTexture)
 {
  return Device3D->UpdateTexture(pSourceTexture,pDestinationTexture);
 }
 HRESULT __stdcall GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface)
 {
  return Device3D->GetRenderTargetData(pRenderTarget,pDestSurface);
 }
 HRESULT __stdcall GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface)
 {
  return Device3D->GetFrontBufferData(iSwapChain,pDestSurface);
 }
 HRESULT __stdcall StretchRect(IDirect3DSurface9* S,CONST RECT* R,IDirect3DSurface9* F,CONST RECT* D,D3DTEXTUREFILTERTYPE Filter)
 {
  return Device3D->StretchRect(S,R,F,D,Filter);
 }
 HRESULT __stdcall ColorFill( IDirect3DSurface9* pSurface,CONST RECT* pRect,D3DCOLOR color)
 {
  return Device3D->ColorFill(pSurface,pRect,color);
 }
 HRESULT __stdcall CreateOffscreenPlainSurface(UINT W,UINT Y,D3DFORMAT F,D3DPOOL P,IDirect3DSurface9** S,HANDLE* H) 
 {
  return Device3D->CreateOffscreenPlainSurface(W,Y,F,P,S,H) ;
 }
 HRESULT __stdcall SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget) 
 {
  return Device3D->SetRenderTarget(RenderTargetIndex,pRenderTarget);
 }
 HRESULT __stdcall GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget)
 {
  return Device3D->GetRenderTarget(RenderTargetIndex,ppRenderTarget);
 }
 HRESULT __stdcall SetDepthStencilSurface( IDirect3DSurface9* pNewZStencil)
 {
  return Device3D->SetDepthStencilSurface(pNewZStencil);
 }
 HRESULT __stdcall GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface)
 {
  return Device3D->GetDepthStencilSurface(ppZStencilSurface);
 }
 HRESULT __stdcall BeginScene(void)
 {
  return Device3D->BeginScene();
 }

 HRESULT __stdcall EndScene(void);

 HRESULT __stdcall Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil)
 {
  return Device3D->Clear(Count,pRects,Flags,Color,Z,Stencil);
 }
 HRESULT __stdcall SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
 {
  return Device3D->SetTransform(State,pMatrix);
 }
 HRESULT __stdcall GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix)
 {
  return Device3D->GetTransform(State,pMatrix);
 }
 HRESULT __stdcall MultiplyTransform(D3DTRANSFORMSTATETYPE a,CONST D3DMATRIX* b)
 {
  return Device3D->MultiplyTransform(a,b);
 }
 HRESULT __stdcall SetViewport(CONST D3DVIEWPORT9* pViewport)
 {
  return Device3D->SetViewport(pViewport);
 }
 HRESULT __stdcall GetViewport(D3DVIEWPORT9* pViewport)
 {
  return Device3D->GetViewport(pViewport);
 }
 HRESULT __stdcall SetMaterial(CONST D3DMATERIAL9* pMaterial)
 {
  return Device3D->SetMaterial(pMaterial);
 }
 HRESULT __stdcall GetMaterial(D3DMATERIAL9* pMaterial)
 {
  return Device3D->GetMaterial(pMaterial);
 }
 HRESULT __stdcall SetLight(DWORD Index,CONST D3DLIGHT9* a)
 {
  return Device3D->SetLight(Index,a);
 }
 HRESULT __stdcall GetLight(DWORD Index,D3DLIGHT9* a)
 {
  return Device3D->GetLight(Index,a);
 }
 HRESULT __stdcall LightEnable(DWORD Index,BOOL Enable)
 {
  return Device3D->LightEnable(Index,Enable);
 }
 HRESULT __stdcall GetLightEnable(DWORD Index,BOOL* pEnable)
 {
  return Device3D->GetLightEnable(Index,pEnable);
 }
 HRESULT __stdcall SetClipPlane(DWORD Index,CONST float* pPlane)
 {
  return Device3D->SetClipPlane(Index,pPlane);
 }
 HRESULT __stdcall GetClipPlane(DWORD Index,float* pPlane)
 {
  return Device3D->GetClipPlane(Index,pPlane);
 }
 HRESULT __stdcall SetRenderState(D3DRENDERSTATETYPE State,DWORD Value)
 {
  return Device3D->SetRenderState(State,Value);
 }
 HRESULT __stdcall GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue)
 {
  return Device3D->GetRenderState(State,pValue);
 }
 HRESULT __stdcall CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9** ppSB)
 {
  return Device3D->CreateStateBlock(Type,ppSB);
 }
 HRESULT __stdcall BeginStateBlock(void)
 {
  return Device3D->BeginStateBlock();
 }
 HRESULT __stdcall EndStateBlock(IDirect3DStateBlock9** ppSB)
 {
  return Device3D->EndStateBlock(ppSB);
 }
 HRESULT __stdcall SetClipStatus(CONST D3DCLIPSTATUS9* pClipStatus)
 {
  return Device3D->SetClipStatus(pClipStatus);
 }
 HRESULT __stdcall GetClipStatus( D3DCLIPSTATUS9* pClipStatus)
 {
  return Device3D->GetClipStatus(pClipStatus);
 }
 HRESULT __stdcall GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture)
 {
  return Device3D->GetTexture(Stage,ppTexture);
 }
 HRESULT __stdcall SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture)
 {
  return Device3D->SetTexture(Stage,pTexture);
 }
 HRESULT __stdcall GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue)
 {
  return Device3D->GetTextureStageState(Stage,Type,pValue);
 }
 HRESULT __stdcall SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value)
 {
  return Device3D->SetTextureStageState(Stage,Type,Value);
 }
 HRESULT __stdcall GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue)
 {
  return Device3D->GetSamplerState(Sampler,Type,pValue);
 }
 HRESULT __stdcall SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value)
 {
  return Device3D->SetSamplerState(Sampler,Type,Value);
 }
 HRESULT __stdcall ValidateDevice(DWORD* pNumPasses)
 {
  return Device3D->ValidateDevice(pNumPasses);
 }
 HRESULT __stdcall SetPaletteEntries(UINT PaletteNumber,CONST PALETTEENTRY* pEntries)
 {
  return Device3D->SetPaletteEntries(PaletteNumber,pEntries);
 }
 HRESULT __stdcall GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries)
 {
  return Device3D->GetPaletteEntries(PaletteNumber,pEntries);
 }
 HRESULT __stdcall SetCurrentTexturePalette(UINT PaletteNumber)
 {
  return Device3D->SetCurrentTexturePalette(PaletteNumber);
 }
 HRESULT __stdcall GetCurrentTexturePalette(UINT *PaletteNumber)
 {
  return Device3D->GetCurrentTexturePalette(PaletteNumber);
 }
 HRESULT __stdcall SetScissorRect(CONST RECT* pRect)
 {
  return Device3D->SetScissorRect(pRect);
 }
 HRESULT __stdcall GetScissorRect(RECT* pRect)
 {
  return Device3D->GetScissorRect(pRect);
 }
 HRESULT __stdcall SetSoftwareVertexProcessing(BOOL bSoftware)
 {
  return Device3D->SetSoftwareVertexProcessing(bSoftware);
 }
 BOOL __stdcall GetSoftwareVertexProcessing(void) 
 {
  return Device3D->GetSoftwareVertexProcessing();
 }
 HRESULT __stdcall SetNPatchMode(float nSegments)
 {
  return Device3D->SetNPatchMode(nSegments);
 }
 float __stdcall GetNPatchMode(void)
 {
  return Device3D->GetNPatchMode();
 }
 HRESULT __stdcall DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount)
 {
  return Device3D->DrawPrimitive(PrimitiveType,StartVertex,PrimitiveCount);
 }
 HRESULT __stdcall DrawIndexedPrimitive(D3DPRIMITIVETYPE a,INT Base,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
 {
  return Device3D->DrawIndexedPrimitive(a,Base,MinVertexIndex,NumVertices,startIndex,primCount);
 }
 HRESULT __stdcall DrawPrimitiveUP(D3DPRIMITIVETYPE Type,UINT Count,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
 {
  return Device3D->DrawPrimitiveUP(Type,Count,pVertexStreamZeroData,VertexStreamZeroStride);
 }
 HRESULT __stdcall DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE P,UINT M,UINT N,UINT C,CONST void* I,D3DFORMAT F,CONST void* V,UINT Z)
 {
  return Device3D->DrawIndexedPrimitiveUP(P,M,N,C,I,F,V,Z);
 }
 HRESULT __stdcall ProcessVertices(UINT S,UINT D,UINT V,IDirect3DVertexBuffer9* B,IDirect3DVertexDeclaration9* VertexDecl,DWORD Flags)
 {
  return Device3D->ProcessVertices(S,D,V,B,VertexDecl,Flags);
 }
 HRESULT __stdcall CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl)
 {
  return Device3D->CreateVertexDeclaration(pVertexElements,ppDecl);
 }
 HRESULT __stdcall SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl)
 {
  return Device3D->SetVertexDeclaration(pDecl);
 }
 HRESULT __stdcall GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl)
 {
  return Device3D->GetVertexDeclaration(ppDecl);
 }
 HRESULT __stdcall SetFVF(DWORD FVF)
 {
  return Device3D->SetFVF(FVF);
 }
 HRESULT __stdcall GetFVF(DWORD* pFVF)
 {
  return Device3D->GetFVF(pFVF);
 }
 HRESULT __stdcall CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader)
 {
  return Device3D->CreateVertexShader(pFunction,ppShader);
 }
 HRESULT __stdcall SetVertexShader(IDirect3DVertexShader9* pShader)
 {
  return Device3D->SetVertexShader(pShader);
 }
 HRESULT __stdcall GetVertexShader(IDirect3DVertexShader9** ppShader)
 {
  return Device3D->GetVertexShader(ppShader);
 }
 HRESULT __stdcall SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
 {
  return Device3D->SetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount);
 }
 HRESULT __stdcall GetVertexShaderConstantF( UINT StartRegister,float* pConstantData,UINT Vector4fCount) 
 {
  return Device3D->GetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount);
 }
 HRESULT __stdcall SetVertexShaderConstantI( UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
 {
  return Device3D->SetVertexShaderConstantI(StartRegister,pConstantData,Vector4iCount);
 }
 HRESULT __stdcall GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
 {
  return Device3D->GetVertexShaderConstantI(StartRegister,pConstantData,Vector4iCount);
 }
 HRESULT __stdcall SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount)
 {
  return Device3D->SetVertexShaderConstantB(StartRegister,pConstantData,BoolCount);
 }
 HRESULT __stdcall GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
 {
  return Device3D->GetVertexShaderConstantB(StartRegister,pConstantData,BoolCount);
 }
 HRESULT __stdcall SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
 {
  return Device3D->SetStreamSource(StreamNumber,pStreamData,OffsetInBytes,Stride);
 }
 HRESULT __stdcall GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* pOffsetInBytes,UINT* pStride)
 {
  return Device3D->GetStreamSource(StreamNumber,ppStreamData,pOffsetInBytes,pStride);
 }
 HRESULT __stdcall SetStreamSourceFreq(UINT StreamNumber,UINT Setting)
 {
  return Device3D->SetStreamSourceFreq(StreamNumber,Setting);
 }
 HRESULT __stdcall GetStreamSourceFreq(UINT StreamNumber,UINT* pSetting)
 {
  return Device3D->GetStreamSourceFreq(StreamNumber,pSetting);
 }
 HRESULT __stdcall SetIndices(IDirect3DIndexBuffer9* pIndexData)
 {
  return Device3D->SetIndices(pIndexData);
 }
 HRESULT __stdcall GetIndices(IDirect3DIndexBuffer9** ppIndexData)
 {
  return Device3D->GetIndices(ppIndexData);
 }
 HRESULT __stdcall CreatePixelShader( CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader)
 {
  return Device3D->CreatePixelShader(pFunction,ppShader);
 }
 HRESULT __stdcall SetPixelShader(IDirect3DPixelShader9* pShader)
 {
  return Device3D->SetPixelShader(pShader);
 }
 HRESULT __stdcall GetPixelShader(IDirect3DPixelShader9** ppShader)
 {
  return Device3D->GetPixelShader(ppShader);
 }
 HRESULT __stdcall SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
 {
  return Device3D->SetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount);
 }
 HRESULT __stdcall GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
 {
  return Device3D->GetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount);
 }
 HRESULT __stdcall SetPixelShaderConstantI( UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
 {
  return Device3D->SetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount);
 }
 HRESULT __stdcall GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
 {
  return Device3D->GetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount);
 }
 HRESULT __stdcall SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount)
 {
  return Device3D->SetPixelShaderConstantB(StartRegister,pConstantData,BoolCount);
 }
 HRESULT __stdcall GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
 {
  return Device3D->GetPixelShaderConstantB(StartRegister,pConstantData,BoolCount);
 }
 HRESULT __stdcall DrawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo)
 {
  return Device3D->DrawRectPatch(Handle,pNumSegs,pRectPatchInfo);
 }
 HRESULT __stdcall DrawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo)
 {
  return Device3D->DrawTriPatch(Handle,pNumSegs,pTriPatchInfo);
 }
 HRESULT __stdcall DeletePatch(UINT Handle)
 {
  return Device3D->DeletePatch(Handle);
 }
 HRESULT __stdcall CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery)
 {
  return Device3D->CreateQuery(Type,ppQuery);
 }
};