Code:
/* Direct3D9 Device */
#include <windows.h>
#include "main.h"
#include "d3d9.h"
#include "stdio.h"
#define D3DHOOK_TEXTURES //comment this to disable texture hooking
#define PI 3.14159265
bool shoot;
bool shootwall;
bool xhair;
bool Chams;
UINT m_Stride;
UINT modelrec;
ID3DXLine *pLine;
LPD3DXFONT pFont;
LPDIRECT3DDEVICE9 pDevice;
IDirect3DPixelShader9* shaderRed;
IDirect3DPixelShader9* shaderBlue;
D3DVIEWPORT9 Viewport;
D3DCOLOR dCIRCLE = D3DCOLOR_ARGB( 255, 0, 255, 0);//green
D3DCOLOR dCIRCLE2 = D3DCOLOR_ARGB( 255, 255, 0, 0);//red
void TriggerBotWall()
{
COLORREF cPixelb;
COLORREF cPixelb2;
HWND d3dhwnd2;
HDC d3ddc2;
d3dhwnd2 = GetForegroundWindow();
d3ddc2 = GetDC(d3dhwnd2);
{
cPixelb = GetPixel( d3ddc2, (Viewport.Width/2)-3, (Viewport.Height/2)-2);
cPixelb2 = GetPixel( d3ddc2, (Viewport.Width/2)+3, (Viewport.Height/2)-2);
// shootAT BLUE Chams (thru walls)
if(GetRValue(cPixelb)<= 100
&& GetGValue(cPixelb)<= 100
&& GetBValue(cPixelb)>= 200
&& GetRValue(cPixelb2)<= 100
&& GetGValue(cPixelb2)<= 100
&& GetBValue(cPixelb2)>= 200)
{
// QUICKSCOPE METHOD - SORT of works
// keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | 0,0);// assign Right CTRL to scope and toggle aim off
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, NULL, NULL); // Simulate click
mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, NULL, NULL);
// keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,0);
//mouse_event(MOUSEEVENTF_ABSOLUTE,((Viewport.Width/2)* (65535/Viewport.Width)),((Viewport.Height/2)-4* (65535/Viewport.Height)), NULL, NULL);
}
} // End X loop
ReleaseDC(d3dhwnd2,d3ddc2);
}
void TriggerBot()
{
COLORREF cPixelr;
COLORREF cPixelr2;
HWND d3dhwnd;
HDC d3ddc;
d3dhwnd = GetForegroundWindow();
d3ddc = GetDC(d3dhwnd);
{
cPixelr = GetPixel( d3ddc, (Viewport.Width/2)-3, (Viewport.Height/2)-2);
cPixelr2 = GetPixel( d3ddc, (Viewport.Width/2)+3, (Viewport.Height/2)-2);
// AIM AT BLUE Chams
//if(GetRValue(cPixel)<= 74
//&& GetGValue(cPixel)<= 74
//&& GetBValue(cPixel)>= 250)
// AIM AT RED Chams
if(GetRValue(cPixelr)>= 220
&& GetGValue(cPixelr)<= 100
&& GetBValue(cPixelr)<= 100
&& GetRValue(cPixelr2)>= 220
&& GetGValue(cPixelr2)<= 100
&& GetBValue(cPixelr2)<= 100)
{
//keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | 0,0);// bad quickscope attempt assign Right CTRL to scope and toggle aim off
//keybd_event(VK_RCONTROL, 0xA3, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP,0);mouse_event(MOUSEEVENTF_LEFTDOW N, 0, 0, NULL, NULL); // Simulate click
mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, NULL, NULL); // Simulate click
mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,((Viewport.Width/2)* (65535/Viewport.Width)),((Viewport.Height/2)* (65535/Viewport.Height)), NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,((Viewport.Width/2)* (65535/Viewport.Width)),((Viewport.Height/2+2)* (65535/Viewport.Height)), NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,(Viewport.Width/2)+4,(Viewport.Height/2)-4, NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,(Viewport.Width/2)-4,(Viewport.Height/2)+4, NULL, NULL);
//mouse_event(MOUSEEVENTF_ABSOLUTE,(Viewport.Width/2),(Viewport.Height/2)-4, NULL, NULL);
//mouse_event(MOUSEEVENTF_MOVE,0,20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,20,-20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,-20,20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,-20,-20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,20,20,0,0);
//mouse_event(MOUSEEVENTF_MOVE,0,-20,0,0)
}
}
ReleaseDC(d3dhwnd,d3ddc);
} // End X loop
//void DrawCircle(int X, int Y, int radius, int numSides, DWORD Color)
//{
// D3DXVECTOR2 Line[128];
// float Step = PI * 2.0 / numSides;
// int Count = 0;
// for (float a=0; a < PI*2.0; a += Step)
// {
// float X1 = radius * cos(a) + X;
// float Y1 = radius * sin(a) + Y;
// float X2 = radius * cos(a+Step) + X;
// float Y2 = radius * sin(a+Step) + Y;
// Line[Count].x = X1;
// Line[Count].y = Y1;
// Line[Count+1].x = X2;
// Line[Count+1].y = Y2;
// Count += 2;
// }
// pLine->Begin();
// pLine->Draw(Line,Count,Color);
// pLine->End();
// pLine->Release();
//}
HRESULT GenerateShader(IDirect3DDevice9 *pD3Ddev, IDirect3DPixelShader9 **pShader, float r, float g, float b, float a)
{
char szShader[256];
ID3DXBuffer *pShaderBuf = NULL;
sprintf_s (szShader, "ps_2_0\ndef c0, %f, %f, %f, %f\nmov oC0, c0", r, g, b, a);
D3DXAssembleShader(szShader, sizeof(szShader), NULL, NULL, 0, &pShaderBuf, NULL);
if(FAILED(pD3Ddev->CreatePixelShader((const DWORD*)pShaderBuf->GetBufferPointer(), pShader)))
return E_FAIL;
return S_OK;
}
HRESULT CD3DManager::Initialize()
{
/*
initialize Resources such as textures
(managed and unmanaged [D3DPOOL]),
vertex buffers, and other D3D rendering resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
GenerateShader(m_pD3Ddev, &shaderRed, 255, 0, 0, 255);
GenerateShader(m_pD3Ddev, &shaderBlue, 0, 0, 255, 255);
return S_OK;
}
HRESULT CD3DManager::PreReset()
{
/*
release all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other
volitile resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
return S_OK;
}
HRESULT CD3DManager::PostReset()
{
/*
re-initialize all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other volitile
resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
return S_OK;
}
HRESULT CD3DManager::Release()
{
/*
Release all textures, vertex buffers, and
other resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
return S_OK;
}
//-----------------------------------------------------------------------------
HRESULT APIENTRY hkIDirect3DDevice9::QueryInterface(REFIID riid, LPVOID *ppvObj)
{
return m_pD3Ddev->QueryInterface(riid, ppvObj);
}
ULONG APIENTRY hkIDirect3DDevice9::AddRef()
{
m_refCount++;
return m_pD3Ddev->AddRef();
}
HRESULT APIENTRY hkIDirect3DDevice9::BeginScene()
{
m_pD3Ddev->GetViewport(&Viewport);
if (GetAsyncKeyState(VK_INSERT)&1)
{
Chams = !Chams;
}
if (GetAsyncKeyState(VK_HOME)&1)
{
xhair = !xhair;
}
if (GetAsyncKeyState(VK_DELETE)&1)
{
shoot = !shoot;
}
if (GetAsyncKeyState(VK_END)&1)
{
shootwall = !shootwall;
}
return m_pD3Ddev->BeginScene();
}
HRESULT APIENTRY hkIDirect3DDevice9::BeginStateBlock()
{
return m_pD3Ddev->BeginStateBlock();
}
HRESULT APIENTRY hkIDirect3DDevice9::Clear(DWORD Count, CONST D3DRECT *pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil)
{
return m_pD3Ddev->Clear(Count, pRects, Flags, Color, Z, Stencil);
}
HRESULT APIENTRY hkIDirect3DDevice9::ColorFill(IDirect3DSurface9* pSurface,CONST RECT* pRect, D3DCOLOR color)
{
return m_pD3Ddev->ColorFill(pSurface,pRect,color);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateAdditionalSwapChain(D3DP RESENT_PARAMETERS *pPresentationParameters, IDirect3DSwapChain9 **ppSwapChain)
{
return m_pD3Ddev->CreateAdditionalSwapChain(pPresentationParameters, ppSwapChain);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateDepthStencilSurface(Width, Height, Format, MultiSample, MultisampleQuality,Discard,ppSurface, pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateOffscreenPlainSurface(UI NT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateOffscreenPlainSurface(Width,Height,Format,Po ol,ppSurface,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader)
{
return m_pD3Ddev->CreatePixelShader(pFunction, ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery)
{
if (m_Stride = 32)
{
if( Type == D3DQUERYTYPE_OCCLUSION )
{
Type = D3DQUERYTYPE_EVENT;
}
}
return m_pD3Ddev->CreateQuery(Type,ppQuery);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateRenderTarget(Width, Height, Format, MultiSample,MultisampleQuality, Lockable, ppSurface,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateStateBlock(D3DSTATEBLOCK TYPE Type,IDirect3DStateBlock9** ppSB)
{
return m_pD3Ddev->CreateStateBlock(Type, ppSB);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,HANDLE* pSharedHandle)
{
HRESULT ret = m_pD3Ddev->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
#ifdef D3DHOOK_TEXTURES
if(ret == D3D_OK) { new hkIDirect3DTexture9(ppTexture, this, Width, Height, Format); }
#endif
return ret;
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl)
{
return m_pD3Ddev->CreateVertexDeclaration(pVertexElements,ppDecl);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader)
{
return m_pD3Ddev->CreateVertexShader(pFunction, ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,HANDLE* pSharedHandle)
{
return m_pD3Ddev->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture,pSharedHandle);
}
HRESULT APIENTRY hkIDirect3DDevice9::DeletePatch(UINT Handle)
{
return m_pD3Ddev->DeletePatch(Handle);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawIndexedPrimitive(D3DPRIMIT IVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
UINT modelrec;
modelrec = ((m_Stride == 32 && ((primCount != 0)||(primCount <= 18) ||(primCount == 25) || (primCount == 53)|| (primCount == 76)|| (primCount == 80)|| (primCount == 104)|| (primCount == 107)|| (primCount == 125)|| (primCount == 131)|| (primCount == 145)|| (primCount == 166)|| (primCount == 190)|| (primCount == 292)|| (primCount == 361)|| (primCount == 389)|| (primCount == 417)|| (primCount == 436)|| (primCount == 452)|| (primCount == 471)|| (primCount == 597)|| (primCount == 874)|| (primCount == 1101)|| (primCount == 1333)|| (primCount == 1446)|| (primCount == 2836))));
if (Chams)
{
//EXTRA FAR LOD HEADS (primCount): TO DO
// FAR LOD HEADS (primCount): 25, 36(ALSOREDDOT), 125(skimask), 131(towel),145,166(towel2),190,292
// MEDIUM LOD HEADS (primCount): 76, 104,107,361(skimask),389(towel2),436(towel),597,87 4,1446
// CLOSE LOD HEADS (primCount): 417,452,471,1101(skimask),1333,1376(towel),1437(to wel2),2836
if ((m_Stride == 32 && ((primCount <= 25) || (primCount == 53)|| (primCount == 76)|| (primCount == 80)|| (primCount == 104)|| (primCount == 107)|| (primCount == 125)|| (primCount == 131)|| (primCount == 145)|| (primCount == 166)|| (primCount == 190)|| (primCount == 292)|| (primCount == 361)|| (primCount == 389)|| (primCount == 417)|| (primCount == 436)|| (primCount == 452)|| (primCount == 471)|| (primCount == 597)|| (primCount == 874)|| (primCount == 1101)|| (primCount == 1333)|| (primCount == 1446)|| (primCount == 2836))))//FIX THIS
{
DWORD dwOldZEnable = D3DZB_TRUE;
m_pD3Ddev->GetRenderState(D3DRS_ZENABLE, &dwOldZEnable);
m_pD3Ddev->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
m_pD3Ddev->SetTexture(0, NULL );
m_pD3Ddev->SetPixelShader( NULL );
m_pD3Ddev->SetPixelShader( shaderBlue );
m_pD3Ddev->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
m_pD3Ddev->DrawIndexedPrimitive(Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
m_pD3Ddev->SetRenderState(D3DRS_ZENABLE, dwOldZEnable);
m_pD3Ddev->SetRenderState(D3DRS_ZFUNC, D3DCMP_LESSEQUAL);
m_pD3Ddev->SetTexture(0, NULL );
m_pD3Ddev->SetPixelShader( NULL );
m_pD3Ddev->SetPixelShader( shaderRed );
}
}
if (xhair)
{
if ((m_Stride == 32 && ((primCount == 34 )||(primCount == 36))))// CULL RED DOT FROM ACOG (SO COLOR TRIGGERBOTS WORK BETTER) NO FIX FOR SNIPERSCOPES
{
DWORD dwOldZEnable = D3DZB_TRUE;
m_pD3Ddev->SetTexture(0, NULL );
m_pD3Ddev->DrawIndexedPrimitive(Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
m_pD3Ddev->SetTexture(0, NULL );
}
}
return m_pD3Ddev->DrawIndexedPrimitive(Type,BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIM ITIVETYPE PrimitiveType, UINT MinIndex, UINT NumVertices, UINT PrimitiveCount, CONST void *pIndexData, D3DFORMAT IndexDataFormat, CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawIndexedPrimitiveUP(PrimitiveType, MinIndex, NumVertices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType, UINT StartVertex, UINT PrimitiveCount)
{
return m_pD3Ddev->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETY PE PrimitiveType, UINT PrimitiveCount, CONST void *pVertexStreamZeroData, UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawRectPatch(UINT Handle, CONST float *pNumSegs, CONST D3DRECTPATCH_INFO *pRectPatchInfo)
{
return m_pD3Ddev->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo);
}
HRESULT APIENTRY hkIDirect3DDevice9::DrawTriPatch(UINT Handle, CONST float *pNumSegs, CONST D3DTRIPATCH_INFO *pTriPatchInfo)
{
return m_pD3Ddev->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo);
}
HRESULT APIENTRY hkIDirect3DDevice9::EndScene()
{
if (shoot)
{
TriggerBot();
}
if (shootwall)
{
TriggerBotWall();
}
if(xhair)
{
D3DRECT aimdot3 = {(Viewport.Width/2)-1,(Viewport.Height/2)-2, (Viewport.Width/2)+1,(Viewport.Height/2)};
m_pD3Ddev->Clear(1, &aimdot3, D3DCLEAR_TARGET,dCIRCLE2, 0, 0);
}
return m_pD3Ddev->EndScene();
}
HRESULT APIENTRY hkIDirect3DDevice9::EndStateBlock(IDirect3DStateBl ock9** ppSB)
{
return m_pD3Ddev->EndStateBlock(ppSB);
}
HRESULT APIENTRY hkIDirect3DDevice9::EvictManagedResources()
{
return m_pD3Ddev->EvictManagedResources();
}
UINT APIENTRY hkIDirect3DDevice9::GetAvailableTextureMem()
{
return m_pD3Ddev->GetAvailableTextureMem();
}
HRESULT APIENTRY hkIDirect3DDevice9::GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9** ppBackBuffer)
{
return m_pD3Ddev->GetBackBuffer(iSwapChain,iBackBuffer, Type, ppBackBuffer);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetClipPlane(DWORD Index, float *pPlane)
{
return m_pD3Ddev->GetClipPlane(Index, pPlane);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetClipStatus(D3DCLIPSTATUS9 *pClipStatus)
{
return m_pD3Ddev->GetClipStatus(pClipStatus);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetCreationParameters(D3DDEVIC E_CREATION_PARAMETERS *pParameters)
{
return m_pD3Ddev->GetCreationParameters(pParameters);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetCurrentTexturePalette(UINT *pPaletteNumber)
{
return m_pD3Ddev->GetCurrentTexturePalette(pPaletteNumber);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDepthStencilSurface(IDirect 3DSurface9 **ppZStencilSurface)
{
return m_pD3Ddev->GetDepthStencilSurface(ppZStencilSurface);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDeviceCaps(D3DCAPS9 *pCaps)
{
return m_pD3Ddev->GetDeviceCaps(pCaps);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDirect3D(IDirect3D9 **ppD3D9)
{
HRESULT hRet = m_pD3Ddev->GetDirect3D(ppD3D9);
if( SUCCEEDED(hRet) )
*ppD3D9 = m_pD3Dint;
return hRet;
}
HRESULT APIENTRY hkIDirect3DDevice9::GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode)
{
return m_pD3Ddev->GetDisplayMode(iSwapChain,pMode);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface)
{
return m_pD3Ddev->GetFrontBufferData(iSwapChain,pDestSurface);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetFVF(DWORD* pFVF)
{
return m_pD3Ddev->GetFVF(pFVF);
}
void APIENTRY hkIDirect3DDevice9::GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->GetGammaRamp(iSwapChain,pRamp);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetIndices(IDirect3DIndexBuffe r9** ppIndexData)
{
return m_pD3Ddev->GetIndices(ppIndexData);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetLight(DWORD Index, D3DLIGHT9 *pLight)
{
return m_pD3Ddev->GetLight(Index, pLight);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetLightEnable(DWORD Index, BOOL *pEnable)
{
return m_pD3Ddev->GetLightEnable(Index, pEnable);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetMaterial(D3DMATERIAL9 *pMaterial)
{
return m_pD3Ddev->GetMaterial(pMaterial);
}
float APIENTRY hkIDirect3DDevice9::GetNPatchMode()
{
return m_pD3Ddev->GetNPatchMode();
}
unsigned int APIENTRY hkIDirect3DDevice9::GetNumberOfSwapChains()
{
return m_pD3Ddev->GetNumberOfSwapChains();
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPaletteEntries(UINT PaletteNumber, PALETTEENTRY *pEntries)
{
return m_pD3Ddev->GetPaletteEntries(PaletteNumber, pEntries);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShader(IDirect3DPixelS hader9** ppShader)
{
return m_pD3Ddev->GetPixelShader(ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->GetPixelShaderConstantB(StartRegister,pConstantDat a,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->GetPixelShaderConstantF(StartRegister,pConstantDat a,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->GetPixelShaderConstantI(StartRegister,pConstantDat a,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus)
{
return m_pD3Ddev->GetRasterStatus(iSwapChain,pRasterStatus);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRenderState(D3DRENDERSTATET YPE State, DWORD *pValue)
{
return m_pD3Ddev->GetRenderState(State, pValue);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget)
{
return m_pD3Ddev->GetRenderTarget(RenderTargetIndex,ppRenderTarget);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetRenderTargetData(IDirect3DS urface9* pRenderTarget,IDirect3DSurface9* pDestSurface)
{
return m_pD3Ddev->GetRenderTargetData(pRenderTarget,pDestSurface);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue)
{
return m_pD3Ddev->GetSamplerState(Sampler,Type,pValue);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetScissorRect(RECT* pRect)
{
return m_pD3Ddev->GetScissorRect(pRect);
}
BOOL APIENTRY hkIDirect3DDevice9::GetSoftwareVertexProcessing()
{
return m_pD3Ddev->GetSoftwareVertexProcessing();
}
HRESULT APIENTRY hkIDirect3DDevice9::GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9** ppStreamData,UINT* OffsetInBytes,UINT* pStride)
{
return m_pD3Ddev->GetStreamSource(StreamNumber, ppStreamData,OffsetInBytes, pStride);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetStreamSourceFreq(UINT StreamNumber,UINT* Divider)
{
return m_pD3Ddev->GetStreamSourceFreq(StreamNumber,Divider);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9** pSwapChain)
{
return m_pD3Ddev->GetSwapChain(iSwapChain,pSwapChain);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetTexture(DWORD Stage, IDirect3DBaseTexture9 **ppTexture)
{
return m_pD3Ddev->GetTexture(Stage, ppTexture);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD *pValue)
{
return m_pD3Ddev->GetTextureStageState(Stage, Type, pValue);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetTransform(D3DTRANSFORMSTATE TYPE State, D3DMATRIX *pMatrix)
{
return m_pD3Ddev->GetTransform(State, pMatrix);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexDeclaration(IDirect3D VertexDeclaration9** ppDecl)
{
return m_pD3Ddev->GetVertexDeclaration(ppDecl);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShader(IDirect3DVerte xShader9** ppShader)
{
return m_pD3Ddev->GetVertexShader(ppShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->GetVertexShaderConstantB(StartRegister,pConstantDa ta,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->GetVertexShaderConstantF(StartRegister,pConstantDa ta,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->GetVertexShaderConstantI(StartRegister,pConstantDa ta,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::GetViewport(D3DVIEWPORT9 *pViewport)
{
return m_pD3Ddev->GetViewport(pViewport);
}
HRESULT APIENTRY hkIDirect3DDevice9::LightEnable(DWORD LightIndex, BOOL bEnable)
{
return m_pD3Ddev->LightEnable(LightIndex, bEnable);
}
HRESULT APIENTRY hkIDirect3DDevice9::MultiplyTransform(D3DTRANSFORM STATETYPE State, CONST D3DMATRIX *pMatrix)
{
return m_pD3Ddev->MultiplyTransform(State, pMatrix);
}
HRESULT APIENTRY hkIDirect3DDevice9::Present(CONST RECT *pSourceRect, CONST RECT *pDestRect, HWND hDestWindowOverride, CONST RGNDATA *pDirtyRegion)
{
return m_pD3Ddev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
}
HRESULT APIENTRY hkIDirect3DDevice9::ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9* pDestBuffer,IDirect3DVertexDeclaration9* pVertexDecl,DWORD Flags)
{
return m_pD3Ddev->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer,pVertexDecl, Flags);
}
ULONG APIENTRY hkIDirect3DDevice9::Release()
{
if( --m_refCount == 0 )
m_pManager->Release();
return m_pD3Ddev->Release();
}
HRESULT APIENTRY hkIDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS *pPresentationParameters)
{
m_pManager->PreReset();
HRESULT hRet = m_pD3Ddev->Reset(pPresentationParameters);
if( SUCCEEDED(hRet) )
{
m_PresentParam = *pPresentationParameters;
m_pManager->PostReset();
}
return hRet;
}
HRESULT APIENTRY hkIDirect3DDevice9::SetClipPlane(DWORD Index, CONST float *pPlane)
{
return m_pD3Ddev->SetClipPlane(Index, pPlane);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetClipStatus(CONST D3DCLIPSTATUS9 *pClipStatus)
{
return m_pD3Ddev->SetClipStatus(pClipStatus);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetCurrentTexturePalette(UINT PaletteNumber)
{
return m_pD3Ddev->SetCurrentTexturePalette(PaletteNumber);
}
void APIENTRY hkIDirect3DDevice9::SetCursorPosition(int X, int Y, DWORD Flags)
{
m_pD3Ddev->SetCursorPosition(X, Y, Flags);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetCursorProperties(UINT XHotSpot, UINT YHotSpot, IDirect3DSurface9 *pCursorBitmap)
{
return m_pD3Ddev->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetDepthStencilSurface(IDirect 3DSurface9* pNewZStencil)
{
return m_pD3Ddev->SetDepthStencilSurface(pNewZStencil);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetDialogBoxMode(BOOL bEnableDialogs)
{
return m_pD3Ddev->SetDialogBoxMode(bEnableDialogs);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetFVF(DWORD FVF)
{
return m_pD3Ddev->SetFVF(FVF);
}
void APIENTRY hkIDirect3DDevice9::SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->SetGammaRamp(iSwapChain,Flags, pRamp);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetIndices(IDirect3DIndexBuffe r9* pIndexData)
{
return m_pD3Ddev->SetIndices(pIndexData);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetLight(DWORD Index, CONST D3DLIGHT9 *pLight)
{
return m_pD3Ddev->SetLight(Index, pLight);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetMaterial(CONST D3DMATERIAL9 *pMaterial)
{
return m_pD3Ddev->SetMaterial(pMaterial);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetNPatchMode(float nSegments)
{
return m_pD3Ddev->SetNPatchMode(nSegments);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPaletteEntries(UINT PaletteNumber, CONST PALETTEENTRY *pEntries)
{
return m_pD3Ddev->SetPaletteEntries(PaletteNumber, pEntries);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShader(IDirect3DPixelS hader9* pShader)
{
return m_pD3Ddev->SetPixelShader(pShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->SetPixelShaderConstantB(StartRegister,pConstantDat a,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->SetPixelShaderConstantF(StartRegister,pConstantDat a,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->SetPixelShaderConstantI(StartRegister,pConstantDat a,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetRenderState(D3DRENDERSTATET YPE State, DWORD Value)
{
return m_pD3Ddev->SetRenderState(State, Value);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetRenderTarget(DWORD RenderTargetIndex, IDirect3DSurface9* pRenderTarget)
{
return m_pD3Ddev->SetRenderTarget(RenderTargetIndex,pRenderTarget);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value)
{
return m_pD3Ddev->SetSamplerState(Sampler,Type,Value);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetScissorRect(CONST RECT* pRect)
{
return m_pD3Ddev->SetScissorRect(pRect);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetSoftwareVertexProcessing(BO OL bSoftware)
{
return m_pD3Ddev->SetSoftwareVertexProcessing(bSoftware);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
{
if( StreamNumber == 0 ){m_Stride = Stride;}
return m_pD3Ddev->SetStreamSource(StreamNumber, pStreamData,OffsetInBytes, Stride);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetStreamSourceFreq(UINT StreamNumber,UINT Divider)
{
return m_pD3Ddev->SetStreamSourceFreq(StreamNumber,Divider);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetTexture(DWORD Stage, IDirect3DBaseTexture9 *pTexture)
{
#ifdef D3DHOOK_TEXTURES
IDirect3DDevice9 *dev = NULL;
if(pTexture != NULL && ((hkIDirect3DTexture9*)(pTexture))->GetDevice(&dev) == D3D_OK)
{
if(dev == this)
return m_pD3Ddev->SetTexture(Stage, ((hkIDirect3DTexture9*)(pTexture))->m_D3Dtex);
}
#endif
return m_pD3Ddev->SetTexture(Stage, pTexture);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetTextureStageState(DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value)
{
return m_pD3Ddev->SetTextureStageState(Stage, Type, Value);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetTransform(D3DTRANSFORMSTATE TYPE State, CONST D3DMATRIX *pMatrix)
{
return m_pD3Ddev->SetTransform(State, pMatrix);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexDeclaration(IDirect3D VertexDeclaration9* pDecl)
{
return m_pD3Ddev->SetVertexDeclaration(pDecl);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShader(IDirect3DVerte xShader9* pShader)
{
return m_pD3Ddev->SetVertexShader(pShader);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
{
return m_pD3Ddev->SetVertexShaderConstantB(StartRegister,pConstantDa ta,BoolCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
{
return m_pD3Ddev->SetVertexShaderConstantF(StartRegister,pConstantDa ta,Vector4fCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
{
return m_pD3Ddev->SetVertexShaderConstantI(StartRegister,pConstantDa ta,Vector4iCount);
}
HRESULT APIENTRY hkIDirect3DDevice9::SetViewport(CONST D3DVIEWPORT9 *pViewport)
{
return m_pD3Ddev->SetViewport(pViewport);
}
BOOL APIENTRY hkIDirect3DDevice9::ShowCursor(BOOL bShow)
{
return m_pD3Ddev->ShowCursor(bShow);
}
HRESULT APIENTRY hkIDirect3DDevice9::StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter)
{
return m_pD3Ddev->StretchRect(pSourceSurface,pSourceRect,pDestSurfac e,pDestRect,Filter);
}
HRESULT APIENTRY hkIDirect3DDevice9::TestCooperativeLevel()
{
return m_pD3Ddev->TestCooperativeLevel();
}
HRESULT APIENTRY hkIDirect3DDevice9::UpdateSurface(IDirect3DSurface 9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint)
{
return m_pD3Ddev->UpdateSurface(pSourceSurface,pSourceRect,pDestinat ionSurface,pDestPoint);
}
HRESULT APIENTRY hkIDirect3DDevice9::UpdateTexture(IDirect3DBaseTex ture9 *pSourceTexture, IDirect3DBaseTexture9 *pDestinationTexture)
{
return m_pD3Ddev->UpdateTexture(pSourceTexture, pDestinationTexture);
}
HRESULT APIENTRY hkIDirect3DDevice9::ValidateDevice(DWORD *pNumPasses)
{
return m_pD3Ddev->ValidateDevice(pNumPasses);
}
btw to those who say this is a virus/trojan