Page 1 of 2 12 LastLast
Results 1 to 15 of 19
  1. #1
    megaspeek's Avatar
    Join Date
    Jul 2008
    Posts
    43
    Reputation
    10
    Thanks
    9

    Code for making wallhack

    I DO NOT TAKE CREDIT FOR THIS! I saw it posted on a bulletin that I will not mention here. This is the public version of the model editor used to create wallhack. Enjoy.


    Code:
    //**Color**//
    HRESULT GenerateTexture(IDirect3DDevice9 *pD3Ddev, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
    {
    if( FAILED(pD3Ddev->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, ppD3Dtex, NULL)) )
    return E_FAIL;

    WORD colour16 = ((WORD)((colour32>>28)&0xF)<<12)
    |(WORD)(((colour32>>20)&0xF)<<8)
    |(WORD)(((colour32>>12)&0xF)<<4)
    |(WORD)(((colour32>>4)&0xF)<<0);

    D3DLOCKED_RECT d3dlr;
    (*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
    WORD *pDst16 = (WORD*)d3dlr.pBits;

    for(int xy=0; xy < 8*8; xy++)
    *pDst16++ = colour16;

    (*ppD3Dtex)->UnlockRect(0);

    return S_OK;
    }

    struct pixels
    {
    IDirect3DTexture9 *pBlue, *pRed, *pPurple, *pOrange, *pWhite, *pGreen, *pYellow, *pPink,*pCyan,*pBlack;
    }; pixels pi;

    #define pchamp( x, b, f )
    if( x )
    {
    YourDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
    YourDevice->SetRenderState( D3DRS_ZFUNC, D3DCMP_NEVER );
    YourDevice->SetTexture( 0, NULL );
    YourDevice->SetTexture( 0, f );
    YourDevice->DrawIndexedPrimitive( Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount );
    YourDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
    YourDevice->SetRenderState( D3DRS_ZFUNC,D3DCMP_LESSEQUAL );
    YourDevice->SetTexture( 0, b );
    YourDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
    return YourDevice->DrawIndexedPrimitive( Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount );
    }
    //**//
    EndScene
    Code:
    int color = true;
    if(color)
    {
    GenerateTexture(YourDevice,&pi.pRed, D3DCOLOR_ARGB(255,255,0,0 ));
    GenerateTexture(YourDevice,&pi.pCyan, D3DCOLOR_ARGB(255,0,255,255 ));
    GenerateTexture(YourDevice,&pi.pYellow, D3DCOLOR_ARGB(255,255,255,0 ));
    GenerateTexture(YourDevice,&pi.pBlue, D3DCOLOR_ARGB(255,0,0,255 ));
    GenerateTexture(YourDevice,&pi.pGreen, D3DCOLOR_ARGB(255,0,255,0 ));
    GenerateTexture(YourDevice,&pi.pOrange, D3DCOLOR_ARGB(255,255,165,0 ));
    GenerateTexture(YourDevice,&pi.pPurple, D3DCOLOR_ARGB(255,160,32,240 ));
    GenerateTexture(YourDevice,&pi.pWhite, D3DCOLOR_ARGB(255,255,255,255 ));
    GenerateTexture(YourDevice,&pi.pPink, D3DCOLOR_ARGB(255,255,105,180 ));
    GenerateTexture(YourDevice,&pi.pBlack, D3DCOLOR_ARGB(255,0,0,0 ));
    color = false;
    }
    DrawIndexedPrimitive()
    Code:
    if(chams)
    {
    pchamp(m_Stride == 44,pi.pBlue,pi.pGreen);
    }

  2. #2
    moris's Avatar
    Join Date
    Jul 2008
    Gender
    male
    Location
    USA, but from BG
    Posts
    44
    Reputation
    7
    Thanks
    1
    Now you didnt even out a complier, because you got it off that guy who posted it.

  3. #3
    austinlau1's Avatar
    Join Date
    Jan 2008
    Gender
    male
    Posts
    46
    Reputation
    10
    Thanks
    4
    Its more than just copy and paste.

  4. #4
    Wankster's Avatar
    Join Date
    Jul 2008
    Gender
    male
    Posts
    52
    Reputation
    9
    Thanks
    4
    dude delete your post you fucking noob we dont need the whole world knowing how to make one

  5. #5
    austinlau1's Avatar
    Join Date
    Jan 2008
    Gender
    male
    Posts
    46
    Reputation
    10
    Thanks
    4
    I doubt half the ppl here even know how to use this.

  6. #6
    daddyi's Avatar
    Join Date
    Jul 2008
    Posts
    197
    Reputation
    10
    Thanks
    55
    Doesn't work...This guy just PM'd me with this asking me to give him my aimbot for it..
    Good thing I checked in here and saw it's the same as his.

    Btw, I just compiled this and it doesn't work...

  7. #7
    gudsoldier's Avatar
    Join Date
    Jul 2008
    Gender
    male
    Location
    In your Girlfriends Closet.
    Posts
    1,010
    Reputation
    14
    Thanks
    278
    My Mood
    Mellow
    Lol, yep compiler BloodShed Dev C++ and Visual Basics 6 C++ finds so many errors in it, you have to go line after line, plus it ignores so many rules of C++ I can't begin...
    Last edited by gudsoldier; 07-30-2008 at 06:33 PM. Reason: GJ
    Stop flaming each other, it helps no one, and causes a step backwards rather than a step forwards.

    Read the rules before you decide to voice your opinion.

    Check your Grammar/Spelling/Facts before typing, otherwise I or another member will do it for you. And that just makes you look stupid.

  8. #8
    Synns's Avatar
    Join Date
    May 2007
    Gender
    male
    Posts
    5,173
    Reputation
    170
    Thanks
    2,555
    My Mood
    Bitchy
    I get errors tho :\ ...

    Code:
    --------------------Configuration: TatniumD3D - Win32 Debug--------------------
    Compiling...
    d3d9dev.cpp
    C:Documents and Settings_DesktopD3D9old_workspaced3d9dev.cpp(11) : error C2143: syntax error : missing ';' before 'if'
    C:Documents and Settings_DesktopD3D9old_workspaced3d9dev.cpp(12) : error C2143: syntax error : missing ';' before '{'
    C:Documents and Settings_DesktopD3D9old_workspaced3d9dev.cpp(12) : error C2447: missing function header (old-style formal list?)
    Error executing cl.exe.
    
    TatniumD3D.dll - 3 error(s), 0 warning(s)
    My D3D9dev.cpp -

    Code:
    /*	Direct3D9 Device */
    
    #include <windows.h>
    #include "main.h"
    #include "d3d9.h"
    bool chams;
    UINT m_Stride;
    #define D3DHOOK_TEXTURES //comment this to disable texture hooking
    #define pchamp( x, b, f )
    if( x )
    { 
        m_pD3Ddev->SetRenderState( D3DRS_ZENABLE, FALSE );
        m_pD3Ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_NEVER );
        m_pD3Ddev->SetTexture( 0, NULL );
        m_pD3Ddev->SetTexture( 0, f );
        m_pD3Ddev->DrawIndexedPrimitive( Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount );
       m_pD3Ddev->SetRenderState( D3DRS_ZENABLE, TRUE );
    	m_pD3Ddev->SetRenderState( D3DRS_ZFUNC,D3DCMP_LESSEQUAL );
        m_pD3Ddev->SetTexture( 0, b );
    	m_pD3Ddev->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
    	return m_pD3Ddev->DrawIndexedPrimitive( Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount );
    }
    
    struct pixels
    {
        IDirect3DTexture9 *pBlue, *pRed, *pPurple, *pOrange, *pWhite, *pGreen, *pYellow, *pPink,*pCyan,*pBlack;
    }; pixels pi;
    
    HRESULT GenerateTexture(IDirect3DDevice9 *pD3Ddev, IDirect3DTexture9 **ppD3Dtex, DWORD colour32)
    {
    	if( FAILED(pD3Ddev->CreateTexture(8, 8, 1, 0, D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, ppD3Dtex, NULL)) )
    		return E_FAIL;
    	
    	WORD colour16 =	((WORD)((colour32>>28)&0xF)<<12)
    			|(WORD)(((colour32>>20)&0xF)<<8)
    			|(WORD)(((colour32>>12)&0xF)<<4)
    			|(WORD)(((colour32>>4)&0xF)<<0);
    
    	D3DLOCKED_RECT d3dlr;    
    	(*ppD3Dtex)->LockRect(0, &d3dlr, 0, 0);
    	WORD *pDst16 = (WORD*)d3dlr.pBits;
    
    	for(int xy=0; xy < 8*8; xy++)
    		*pDst16++ = colour16;
    
    	(*ppD3Dtex)->UnlockRect(0);
    
    	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);
    	*/
    	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() 
    {
    	if (GetAsyncKeyState(VK_INSERT)&1)
    {
    	chams = !chams;
    }
    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(D3DPRESENT_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(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,HANDLE* pSharedHandle) 
    {
    	return m_pD3Ddev->CreateOffscreenPlainSurface(Width,Height,Format,Pool,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) 
    {
    	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(D3DSTATEBLOCKTYPE 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(D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount)
    {
    	if(chams)
    {
    	pchamp(m_Stride == 44,pi.pBlue,pi.pGreen);
    }
    	return m_pD3Ddev->DrawIndexedPrimitive(Type,BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE 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(D3DPRIMITIVETYPE 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()
    {
    	int color = true;
    	if(color)
        {
    		GenerateTexture(m_pD3Ddev,&pi.pRed,       D3DCOLOR_ARGB(255,255,0,0      ));
    		GenerateTexture(m_pD3Ddev,&pi.pCyan,      D3DCOLOR_ARGB(255,0,255,255    ));
    		GenerateTexture(m_pD3Ddev,&pi.pYellow,    D3DCOLOR_ARGB(255,255,255,0    ));
    		GenerateTexture(m_pD3Ddev,&pi.pBlue,      D3DCOLOR_ARGB(255,0,0,255      ));
    		GenerateTexture(m_pD3Ddev,&pi.pGreen,     D3DCOLOR_ARGB(255,0,255,0      ));
    		GenerateTexture(m_pD3Ddev,&pi.pOrange,    D3DCOLOR_ARGB(255,255,165,0    ));
    		GenerateTexture(m_pD3Ddev,&pi.pPurple,    D3DCOLOR_ARGB(255,160,32,240   ));
    	    GenerateTexture(m_pD3Ddev,&pi.pWhite,     D3DCOLOR_ARGB(255,255,255,255  ));
    		GenerateTexture(m_pD3Ddev,&pi.pPink,      D3DCOLOR_ARGB(255,255,105,180  ));
    		GenerateTexture(m_pD3Ddev,&pi.pBlack,     D3DCOLOR_ARGB(255,0,0,0        ));
    		color = false;
        }
    	return m_pD3Ddev->EndScene();
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::EndStateBlock(IDirect3DStateBlock9** 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::Ge***ipPlane(DWORD Index, float *pPlane) 
    {
    	return m_pD3Ddev->Ge***ipPlane(Index, pPlane);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::Ge***ipStatus(D3DCLIPSTATUS9 *pClipStatus) 
    {
    	return m_pD3Ddev->Ge***ipStatus(pClipStatus);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters) 
    {
    	return m_pD3Ddev->GetCreationParameters(pParameters);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetCurrentTexturePalette(UINT *pPaletteNumber)
    {
    	return m_pD3Ddev->GetCurrentTexturePalette(pPaletteNumber);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetDepthStencilSurface(IDirect3DSurface9 **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(IDirect3DIndexBuffer9** 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(IDirect3DPixelShader9** ppShader) 
    {
    	return m_pD3Ddev->GetPixelShader(ppShader);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount) 
    {
    	return m_pD3Ddev->GetPixelShaderConstantB(StartRegister,pConstantData,BoolCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount) 
    {
    	return m_pD3Ddev->GetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
    {
    	return m_pD3Ddev->GetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus) 
    {
    	return m_pD3Ddev->GetRasterStatus(iSwapChain,pRasterStatus);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetRenderState(D3DRENDERSTATETYPE 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(IDirect3DSurface9* 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(D3DTRANSFORMSTATETYPE State, D3DMATRIX *pMatrix) 
    {
    	return m_pD3Ddev->GetTransform(State, pMatrix);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetVertexDeclaration(IDirect3DVertexDeclaration9** ppDecl) 
    {
    	return m_pD3Ddev->GetVertexDeclaration(ppDecl);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShader(IDirect3DVertexShader9** ppShader) 
    {
    	return m_pD3Ddev->GetVertexShader(ppShader);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount)
    {
    	return m_pD3Ddev->GetVertexShaderConstantB(StartRegister,pConstantData,BoolCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount) 
    {
    	return m_pD3Ddev->GetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount)
    {
    	return m_pD3Ddev->GetVertexShaderConstantI(StartRegister,pConstantData,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(D3DTRANSFORMSTATETYPE 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::Se***ipPlane(DWORD Index, CONST float *pPlane) 
    {
    	return m_pD3Ddev->Se***ipPlane(Index, pPlane);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::Se***ipStatus(CONST D3DCLIPSTATUS9 *pClipStatus) 
    {
    	return m_pD3Ddev->Se***ipStatus(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(IDirect3DSurface9* 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(IDirect3DIndexBuffer9* 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(IDirect3DPixelShader9* pShader) 
    {
    	return m_pD3Ddev->SetPixelShader(pShader);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount) 
    {
    	return m_pD3Ddev->SetPixelShaderConstantB(StartRegister,pConstantData,BoolCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount) 
    {
    	return m_pD3Ddev->SetPixelShaderConstantF(StartRegister,pConstantData,Vector4fCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount) 
    {
    	return m_pD3Ddev->SetPixelShaderConstantI(StartRegister,pConstantData,Vector4iCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetRenderState(D3DRENDERSTATETYPE 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(BOOL bSoftware) 
    {
    	return m_pD3Ddev->SetSoftwareVertexProcessing(bSoftware);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT 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(D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX *pMatrix) 
    {
    	return m_pD3Ddev->SetTransform(State, pMatrix);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl) 
    {
    	return m_pD3Ddev->SetVertexDeclaration(pDecl);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShader(IDirect3DVertexShader9* pShader) 
    {
    	return m_pD3Ddev->SetVertexShader(pShader);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount) 
    {
    	return m_pD3Ddev->SetVertexShaderConstantB(StartRegister,pConstantData,BoolCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount) 
    {
    	return m_pD3Ddev->SetVertexShaderConstantF(StartRegister,pConstantData,Vector4fCount);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount) 
    {
    	return m_pD3Ddev->SetVertexShaderConstantI(StartRegister,pConstantData,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,pDestSurface,pDestRect,Filter);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::TestCooperativeLevel() 
    {
    	return m_pD3Ddev->TestCooperativeLevel();
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::UpdateSurface(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestinationSurface,CONST POINT* pDestPoint) 
    {
    	return m_pD3Ddev->UpdateSurface(pSourceSurface,pSourceRect,pDestinationSurface,pDestPoint);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::UpdateTexture(IDirect3DBaseTexture9 *pSourceTexture, IDirect3DBaseTexture9 *pDestinationTexture) 
    {
    	return m_pD3Ddev->UpdateTexture(pSourceTexture, pDestinationTexture);
    }
    
    HRESULT APIENTRY hkIDirect3DDevice9::ValidateDevice(DWORD *pNumPasses) 
    {
    	return m_pD3Ddev->ValidateDevice(pNumPasses);
    }

  9. #9
    Wankster's Avatar
    Join Date
    Jul 2008
    Gender
    male
    Posts
    52
    Reputation
    9
    Thanks
    4
    lol if they had a brain it was very easy to figure out the rest

  10. #10
    Greenbox's Avatar
    Join Date
    Jul 2008
    Posts
    14
    Reputation
    10
    Thanks
    0
    You sure CA is D3D9 and not D3D8?

  11. #11
    Synns's Avatar
    Join Date
    May 2007
    Gender
    male
    Posts
    5,173
    Reputation
    170
    Thanks
    2,555
    My Mood
    Bitchy
    Quote Originally Posted by Greenbox View Post
    You sure CA is D3D9 and not D3D8?
    Yes it is, it uses dx9.

  12. #12
    Harold's Avatar
    Join Date
    Jul 2008
    Posts
    302
    Reputation
    23
    Thanks
    855
    This code(that I posted) is NOT COPY PASTEABLE. I will make a tutorial later if the demand is big enough.


    And for all the people saying "don't post this it will get detected". here is the thing, it can be detected regardless but hackshield sucks so badly you can just disable it entirely... So stfu and don't worry about it being detected, because technically it already is.

  13. #13
    gudsoldier's Avatar
    Join Date
    Jul 2008
    Gender
    male
    Location
    In your Girlfriends Closet.
    Posts
    1,010
    Reputation
    14
    Thanks
    278
    My Mood
    Mellow
    I think I'm going to take this into account Harold. I will go and make myself something special to dismantle the Hackshield with the push of a button...
    Stop flaming each other, it helps no one, and causes a step backwards rather than a step forwards.

    Read the rules before you decide to voice your opinion.

    Check your Grammar/Spelling/Facts before typing, otherwise I or another member will do it for you. And that just makes you look stupid.

  14. #14
    Harold's Avatar
    Join Date
    Jul 2008
    Posts
    302
    Reputation
    23
    Thanks
    855
    Quote Originally Posted by gudsoldier View Post
    I think I'm going to take this into account Harold. I will go and make myself something special to dismantle the Hackshield with the push of a button...
    If people cant figure it out ill just post how to as well...

  15. #15
    gbitz's Avatar
    Join Date
    Mar 2008
    Gender
    male
    Posts
    3,002
    Reputation
    152
    Thanks
    224
    Three errors? Pfft. If anyone here besides Harold, Shock and me knew how to code, those errors would be gone in no time.

Page 1 of 2 12 LastLast

Similar Threads

  1. [a little off topic] sellin 7 day ak47 code for warrock
    By m164life in forum WarRock - International Hacks
    Replies: 8
    Last Post: 03-07-2007, 08:33 PM
  2. Unlock code for mobile.
    By Dmx in forum General
    Replies: 4
    Last Post: 01-14-2007, 07:23 PM
  3. SERIAL CODE FOR PHOTOSHOP 9!!!!!!!! 100% working
    By -[standoff]- in forum Art & Graphic Design
    Replies: 10
    Last Post: 07-29-2006, 05:35 AM
  4. Replies: 37
    Last Post: 06-20-2006, 04:24 PM
  5. How I make wallhack?
    By RaidenDXX in forum WarRock - International Hacks
    Replies: 6
    Last Post: 01-23-2006, 01:28 PM

Tags for this Thread