Warrock D3D TuT!

Ok for this tut you will need.

DX8 - Summer SDK
Download details: DirectX 9.0 SDK Update - (Summer 2004)

The Empty D3D folder!
D3D-Empty.rar
(warning: Virus scanners my find teh TitamiumD3D as a virus its not!)

C++6
Can be found in the forums in C++ section!

Ok so download all 3 of these and install the DX8-Summer and install it!
Also install c++6

Once they are installed Take the EmptyD3D folder out the zip file and place it on your desktop! Now open c++6 and then file/Open Workspace
Then direct it to the EmptyD3D and you will see a file named
"TatniumD3D.dsw" double clik it and open it!

This is now all the D3D code! looks mad huh? Now we need to set up the includes and lib files for teh DX9-summer so go to TOOLS/OPTIONS then click on Directories.

Look were it says : Show directories for:
you will see that Include files is selected.
Now under the last include which should be the Visual studion Include

Click under it and 3 dots will appear, click the 3 dots to open anouther window to find your DX8-SummerFolder!

Once you found your directx-8 Summer folder click on the Include folder
and then click on OK

Now to add the Library folder!
Click the arrow under the Show Directories For and click on Library Files
Now you will get this screen!

Now do the same as above! click under the last included file untill the dots appeare then navigate to your DX8-summer folder and then double click on LIB folder and then OK, Then Ok again and the box should close leaveing you looking upon the code!

Now i'm just going to explain the basic because i have also writen help inside the D3D! the text will be green! but i will whizz over it in here to make things more understandable! I'm not great at D3D.

Ok so scroll to the top and look for this part of the code that is in the circle!

This is were we add our hack Addies!
So in this pic we have!

Code:

#define ullammo_Addie1 0x000000
#define ullammo_Addie2 0x000000
#define ullammo_Addie3 0x000000
#define boxs_Addie1 0x00000

Ok so if we were to add anouther hack we would write it like the rest but changeing the hack name! so for instance we will add circles!

Code:

#define ullammo_Addie1 0x000000
#define ullammo_Addie2 0x000000
#define ullammo_Addie3 0x000000
#define boxs_Addie1 0x00000
#define circles_Addie1 0x0000

See simple!

now if you scroll down a little bit you will see

Code:

bool CH_Unlimammo = false;
bool CH_Boxs = false;

Here we must add our new hack the way the others are! so we add circles to the list

Code:

bool CH_Unlimammo = false;
bool CH_Boxs = false;
bool CH_Circles = false;

Now if you scroll a little more you will see this

Code:

int highlight[2] = {1,0};

Now at this point we need to add to the 2 and the 1,0 so now we have added a 3rd hack we change this to look like this!

Code:

int highlight[3] = {1,0,0};

See! make sure you add a ,0 every time also! But i'm sure you dont add these when adding hacks such as Stamina as that is a Offset! but i'll explain this at a later date!

I hope you aint confused? we are just working DOWN and adding things as we go along!

Now under the last bit of code we were looking you will see this!

Code:

char unlimammostring[20] = {NULL};
char boxsstring[20] = {NULL};

Now same again we just add our hack the way these are! so we are working with circles!

Code:

char unlimammostring[20] = {NULL};
char boxsstring[20] = {NULL};
char circlesstring[20] = {NULL};

Ok to carry on we need to scroll down abit to find the freen text saying
ADD HACKS HERE! look at the picture!

Now this can be somewhat confuseing for beginners but once you start adding to the list the easyer it becomes!

Ok so here is the code that we have for the hacks at the moment!

Code:

//----------------------------------------------
//-----------ADD HACKS HERE---------------------
{
	if( CH_Unlimammo ) // UNLIM AMMO!
{
D3D_NOPING( ( void* )ullammo_Addie1, 3);
D3D_NOPING( ( void* )ullammo_Addie2, 3);
D3D_NOPING( ( void* )ullammo_Addie3, 3);
}
{
	if( CH_Boxs )//BOXS
	{
D3D_NOPING( ( void* )boxs_Addie1, 1);
}

//Add hack above here
	{
	return m_pD3Ddev->BeginScene();
}
}
}
//Add anouther } with every hack!

Ok so to add circles we add it above the text were it says
//Add hack above here

So this is our circles hack code

Code:

	{
    if( CH_Circles )//CIRCLES
	{
D3D_NOPING( ( void* )circles_Addie1, 1); // 
}

Now to add it to the list! it will look like this!

Code:

//----------------------------------------------
//-----------ADD HACKS HERE---------------------
{
	if( CH_Unlimammo ) // UNLIM AMMO!
{
D3D_NOPING( ( void* )ullammo_Addie1, 3);
D3D_NOPING( ( void* )ullammo_Addie2, 3);
D3D_NOPING( ( void* )ullammo_Addie3, 3);
}
{
	if( CH_Boxs )//BOXS
	{
D3D_NOPING( ( void* )boxs_Addie1, 1);
}
{
    if( CH_Circles )//CIRCLES
	{
D3D_NOPING( ( void* )circles_Addie1, 1); 
}
//Add hack above here
	{
	return m_pD3Ddev->BeginScene();
}
}
}
} - You add this in as well!
//Add anouther } with every hack!

Have you noticed the "- You add this in as well!"
Ok so you have now added your hack code for circles so now to move on!

Scroll a bit down and you will see this next bit of code that we need to add to!

Ok so copy the code for boxs and paste it underneith! then edit it for the information for circles.

Code:

sprintf(circlesstring, "%s", (CH_Circles ?  "Circles ON" : "Circles OFF"));

This is for the menu, i wounder if you guess what for?
Also if you look up a bit from this bit of code you will see that you can rename the hack, see if you can find it?

Ok now below the las bit of code we added you will see this!

Copy the seccond bunch of code and paste it underneith and edit the parts we need to for circles!

Code:

if(highlight[3]==1)
	          m_pFont_INFO->DrawText(15.0f, 140.0f, txtRed, circlesstring);
                  else
	         m_pFont_INFO->DrawText(15.0f,140.0f, txtGreen, circlesstring);

Ok so i changed the "boxstring to circlesstring" also notice that i changed the "2" to a "3" you must change this number with each hack so the next hack would be "4" Also notcie that i have changed the numbers "130" to "140" (these numbers go up in TENS) if you forget to change this then the text for the hacks in the menu will sit on each other and you wont be able to see the text propper lol.

So now this part will look like this!
(in the big circle thats what we added and the other circles shows you the difference!)

Ok so moveing on!

scroll down a little more till you see this!

Code:

if(GetAsyncKeyState(VK_UP)&1)
      {
	  //ADD +1 to were the 3 is so if its a new hack the 3 will be 4
	  for(int i=0; i < 3; i++)      
	  {
		  if (highlight[i] == 1)
		  {
			  int a = i-1;

			  if(a < 1)
			  break;

		      else 
			  {
		          highlight[a]=1;
			  highlight[i]=0;
			  break;
			  }
		  }
	  }
  }

Ok look at the picture and look at the circled bit!

Ok so you can see that i have circled the number "3" we change this each time we add a hack so now we need to change it to a 4! and when we add anouther hack we change it to 5 and so on,! now scroll down to the next bit of code! This is the same as the code we just looked at! but this time we change two bits of it! Look at the picture

So again the first circle is the same as the above code we change it everytime we add a hack! so change it to a "4"

now the seccond circle we can see is a number "2" thats how many hacks we have! so we change this to a "3" So really when you get to this part the first numbers you change are allways one more up than the seccond number. Understand? you will do once you continue adding hacks!

Ok now for the last bit of codeing! WHOOOOOOOO
Scroll down a little bit untill you see this bit.

Ok now copy the Boxs peice of code and paste it underneith so it will look like this.

Code:

if(highlight[1] == 1 && (GetAsyncKeyState(VK_RIGHT)&1)) 
	  CH_Unlimammo = !CH_Unlimammo;

if(highlight[2] == 1 && (GetAsyncKeyState(VK_RIGHT)&1)) 
	  CH_Boxs = !CH_Boxs;

if(highlight[2] == 1 && (GetAsyncKeyState(VK_RIGHT)&1)) 
	  CH_Boxs = !CH_Boxs;

Now change the new peice for our circles!

Code:

if(highlight[1] == 1 && (GetAsyncKeyState(VK_RIGHT)&1)) 
	  CH_Unlimammo = !CH_Unlimammo;

if(highlight[2] == 1 && (GetAsyncKeyState(VK_RIGHT)&1)) 
	  CH_Boxs = !CH_Boxs;

if(highlight[3] == 1 && (GetAsyncKeyState(VK_RIGHT)&1)) 
	  CH_Circles = !CH_Circles;

And thats it for codeing.........

Lol quite a lot to take in when your starting off but the more you do the quicker you get use to it! A few things could be done to touch it all up but im intrested in getting you started!

Ok now click on Build and then Rebuild All!
Hopefully if you done it all correctly you will get no errors!

Now click build again and then click on Batch Build then RebuildAll.
Now goto the Empty_D3D folder and then Release
You will see that there is a file that says "TatniumD3D" this will make the hack load into warrock so double click it and it should say
"wchang.com D3D press End for end the injection" Click OK
Now open warrock and login! you will see your D3D menu on the left of the screen!

Use the UP and DOWN keys to navigate up and down the list and hit the RIGHT arrow key to select it ON or OFF.

Hope this helpd you!
Credits to slicer for his empty file for me to work from!

#include <windows.h>
#include "main.h"
#include "d3d8.h"
#include "graphic_adds.h"
#include <fstream> //
#include <stdio.h> //these are for your sprintf
#include "d3dfont.h" //this is for the font
#define D3DHOOK_TEXTURES //comment this to disable texture hooking
#define ABCPlayer (m_Stride == 44 || m_Stride == 44) // we declared our Player Body

HANDLE phandle;
HANDLE Wrrk;

CD3DFont* m_pFont_new = NULL;//one for menu
CD3DFont* m_pFont_INFO = NULL;////one for other text (such as a header)
char Display_Line[256];///256 is the max text it will pass
const D3DCOLOR txtRed = D3DCOLOR_ARGB(255, 255, 0, 0);
const D3DCOLOR txtGreen = D3DCOLOR_ARGB(255, 0,255, 0);

void Write_D3Dmem( void* pxAddress, void* pxBuffer )
{
unsigned long Protection;
VirtualProtect((void*)pxAddress, sizeof( pxBuffer ), PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)pxBuffer, sizeof( pxBuffer ));
VirtualProtect((void*)pxAddress, sizeof( pxBuffer ), Protection, 0);
}

///////////////////////////////////////////////// Addies Here!
// Example : #define yourhack_Addie 0x000000
//Add your next hack like the rest
#define ullammo_Addie1 0x000000
#define ullammo_Addie2 0x000000
#define ullammo_Addie3 0x000000
#define boxs_Addie1 0x00000

///////////////////////////////////////////////// End of addies

UINT m_Stride;

bool CH_Menu = true;
//-------------------------------------
//You have to add your hack like thses here!
bool CH_Unlimammo = false;
bool CH_Boxs = false;
bool CH_Circles = false;

//-------------------------------------
// Add a +1 with every hack in the[*] now its [2] next hack = [3]
// Also add a ,0 - so were {1,0} your next hack = {1,0,0}
int highlight[3] = {1,0,0};
//So for next hack it would be - int highlight[3] = {1,0,0}; EASY!

// Declare a string here everytime you add a Hack
//Just add your hack like these here! keeping it at 20
char unlimammostring[20] = {NULL};
char boxsstring[20] = {NULL};
char circlesstring[20] = {NULL};

//After you have added to here scroll down untill you find ADD HACKS HERE
//While you scroll also look at the code on way down to get use to it!

// Below for your FONT text color
const D3DCOLOR textOrange = D3DCOLOR_ARGB(255, 255, 140, 0);
const D3DCOLOR textRed = D3DCOLOR_ARGB(255, 255, 0, 0);
const D3DCOLOR textGreen = D3DCOLOR_ARGB(255,0,255,0);
const D3DCOLOR textWhite = D3DCOLOR_ARGB(255,255,255,255);
const D3DCOLOR textBlue = D3DCOLOR_ARGB(255,0,0,255);
const D3DCOLOR textYellow = D3DCOLOR_ARGB(255,255,255,0);
const D3DCOLOR textPink = D3DCOLOR_ARGB(255,255,192,203);
const D3DCOLOR textBlack = D3DCOLOR_ARGB(255,0,0,0);
const D3DCOLOR textPurple = D3DCOLOR_ARGB(255,160,32,240);

/////////////// Colors ///////////////
LPDIRECT3DTEXTURE8 texRed;
LPDIRECT3DTEXTURE8 texBlue;
LPDIRECT3DTEXTURE8 texGreen;
LPDIRECT3DTEXTURE8 texYellow;
LPDIRECT3DTEXTURE8 texPink;
LPDIRECT3DTEXTURE8 texTur;
LPDIRECT3DTEXTURE8 texOrange;
LPDIRECT3DTEXTURE8 texWhite;
LPDIRECT3DTEXTURE8 texGrenade;
LPDIRECT3DTEXTURE8 texBlack;

//////////////////////////////////////////

void DrawRect(IDirect3DDevice8* Unidade, int baseX, int baseY, int baseW, int baseH, D3DCOLOR Cor)
{
D3DRECT BarRect = { baseX, baseY, baseX + baseW, baseY + baseH };
Unidade->Clear(1, &BarRect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, Cor, 0, 0);
}

HRESULT CD3DManager::Initialize()
{
/*
initialize Resources such as textures
(managed and unmanaged [D3DPOOL]),
vertex buffers, and other D3D rendering resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bRed, 60, &texRed);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bBlue, 60, &texBlue);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bGreen, 60, &texGreen);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bYellow, 60, &texYellow);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bPink, 60, &texPink);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bTur, 60, &texTur);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bOrange, 60, &texOrange);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bWhite, 60, &texWhite);
D3DXCreateTextureFromFileInMemory(m_pD3Ddev, (LPCVOID)&bYellow, 60, &texGrenade); //bGrenade
///////////these are for creating cham colors(incase you didnt know)

// Fonts to show text
m_pFont_new = new CD3DFont("Arial", 13, D3DFONT_BOLD);
m_pFont_new->InitDeviceObjects(m_pD3Ddev);
m_pFont_new->RestoreDeviceObjects();
m_pFont_INFO = new CD3DFont("Arial", 8, D3DFONT_BOLD);
m_pFont_INFO->InitDeviceObjects(m_pD3Ddev);
m_pFont_INFO->RestoreDeviceObjects();

//CH_Chams = true;
phandle = NULL;
Wrrk = GetCurrentProcess();

return S_OK;
}

HRESULT CD3DManager::PreReset()
{
/*
release all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other
volitile resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
m_pFont_new->InvalidateDeviceObjects();
m_pFont_new->DeleteDeviceObjects();
m_pFont_new = NULL;
m_pFont_INFO->InvalidateDeviceObjects();
m_pFont_INFO->DeleteDeviceObjects();
m_pFont_INFO = NULL;

return S_OK;
}

HRESULT CD3DManager::PostReset()
{
/*
re-initialize all UNMANAGED [D3DPOOL_DEFAULT]
textures, vertex buffers, and other volitile
resources
...
m_pD3Ddev->CreateTexture(..., ..., &m_pD3Dtexture);
*/
m_pFont_new = new CD3DFont("Arial", 13, D3DFONT_BOLD);
m_pFont_new->InitDeviceObjects(m_pD3Ddev);
m_pFont_new->RestoreDeviceObjects();
m_pFont_INFO = new CD3DFont("Arial", 8, D3DFONT_BOLD);
m_pFont_INFO->InitDeviceObjects(m_pD3Ddev);
m_pFont_INFO->RestoreDeviceObjects();

return S_OK;
}

//-------------functions-----------------------------------
void D3D_NOPING( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}

void D3D_NOP( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x1C};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}

void D3D_NOPINGS( void* pxAddress, int size )
{
unsigned long Protection;
BYTE IWriteNoFunctions[ ] = {0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99};
VirtualProtect((void*)pxAddress, size, PAGE_READWRITE, &Protection);
memcpy((void*)pxAddress, (const void*)IWriteNoFunctions, size);
VirtualProtect((void*)pxAddress, size, Protection, 0);
}
//----------------------------------------------------------------

HRESULT CD3DManager::Release()
{
/*
Release all textures, vertex buffers, and
other resources
...
_SAFE_RELEASE(m_pD3Dtexture);
*/
m_pFont_new->InvalidateDeviceObjects();
m_pFont_new->DeleteDeviceObjects();
m_pFont_new = NULL;
m_pFont_INFO->InvalidateDeviceObjects();
m_pFont_INFO->DeleteDeviceObjects();
m_pFont_INFO = NULL;

CloseHandle(phandle);
phandle = NULL;

return S_OK;
}

//-----------------------------------------------------------------------------SteeL
//ok watch now everything under this is waht u were missing...
//-----------------------------------------------------------------------------

HRESULT APIENTRY hkIDirect3DDevice8::QueryInterface(REFIID riid, void** ppvObj)
{
return m_pD3Ddev->QueryInterface(riid, ppvObj);
}

ULONG APIENTRY hkIDirect3DDevice8::AddRef(void)
{
m_refCount++;
return m_pD3Ddev->AddRef();
}

ULONG APIENTRY hkIDirect3DDevice8::Release(void)
{
if( --m_refCount == 0 )
m_pManager->Release();

return m_pD3Ddev->Release();
}

HRESULT APIENTRY hkIDirect3DDevice8::TestCooperativeLevel(void)
{
return m_pD3Ddev->TestCooperativeLevel();
}

UINT APIENTRY hkIDirect3DDevice8::GetAvailableTextureMem(void)
{
return m_pD3Ddev->GetAvailableTextureMem();
}

HRESULT APIENTRY hkIDirect3DDevice8::ResourceManagerDiscardBytes(DW ORD Bytes)
{
return m_pD3Ddev->ResourceManagerDiscardBytes(Bytes);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDirect3D(IDirect3D8** ppD3D8)
{
HRESULT hRet = m_pD3Ddev->GetDirect3D(ppD3D8);
if( SUCCEEDED(hRet) )
*ppD3D8 = m_pD3Dint;
return hRet;
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDeviceCaps(D3DCAPS8* pCaps)
{
return m_pD3Ddev->GetDeviceCaps(pCaps);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDisplayMode(D3DDISPLAYMODE* pMode)
{
return m_pD3Ddev->GetDisplayMode(pMode);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetCreationParameters(D3DDEVIC E_CREATION_PARAMETERS *pParameters)
{
return m_pD3Ddev->GetCreationParameters(pParameters);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface8* pCursorBitmap)
{
return m_pD3Ddev->SetCursorProperties(XHotSpot, YHotSpot, pCursorBitmap);
}

void APIENTRY hkIDirect3DDevice8::SetCursorPosition(int X,int Y,DWORD Flags)
{
m_pD3Ddev->SetCursorPosition(X, Y, Flags);
}

BOOL APIENTRY hkIDirect3DDevice8::ShowCursor(BOOL bShow)
{
return m_pD3Ddev->ShowCursor(bShow);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateAdditionalSwapChain(D3DP RESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain8** pSwapChain)
{
return m_pD3Ddev->CreateAdditionalSwapChain(pPresentationParameters , pSwapChain);
}

HRESULT APIENTRY hkIDirect3DDevice8::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 hkIDirect3DDevice8::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
{
return m_pD3Ddev->Present(pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetBackBuffer(UINT BackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface8** ppBackBuffer)
{
return m_pD3Ddev->GetBackBuffer(BackBuffer, Type, ppBackBuffer);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetRasterStatus(D3DRASTER_STAT US* pRasterStatus)
{
return m_pD3Ddev->GetRasterStatus(pRasterStatus);
}

void APIENTRY hkIDirect3DDevice8::SetGammaRamp(DWORD Flags,CONST D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->SetGammaRamp(Flags, pRamp);
}

void APIENTRY hkIDirect3DDevice8::GetGammaRamp(D3DGAMMARAMP* pRamp)
{
m_pD3Ddev->GetGammaRamp(pRamp);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture8** ppTexture)
{
HRESULT hRet = m_pD3Ddev->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture);

#ifdef D3DHOOK_TEXTURES
if(hRet == D3D_OK) { *ppTexture = new hkIDirect3DTexture8(ppTexture, this, Width, Height, Format); }
#endif

return hRet;
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture8** ppVolumeTexture)
{
return m_pD3Ddev->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture8** ppCubeTexture)
{
return m_pD3Ddev->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer8** ppVertexBuffer)
{
return m_pD3Ddev->CreateVertexBuffer(Length, Usage, FVF, Pool, ppVertexBuffer);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer8** ppIndexBuffer)
{
return m_pD3Ddev->CreateIndexBuffer(Length, Usage, Format, Pool, ppIndexBuffer);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,BOOL Lockable,IDirect3DSurface8** ppSurface)
{
return m_pD3Ddev->CreateRenderTarget(Width, Height, Format, MultiSample, Lockable, ppSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,IDirect3DSurface8** ppSurface)
{
return m_pD3Ddev->CreateDepthStencilSurface(Width, Height, Format, MultiSample, ppSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateImageSurface(UINT Width,UINT Height,D3DFORMAT Format,IDirect3DSurface8** ppSurface)
{
return m_pD3Ddev->CreateImageSurface(Width, Height, Format, ppSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::CopyRects(IDirect3DSurface8* pSourceSurface,CONST RECT* pSourceRectsArray,UINT cRects,IDirect3DSurface8* pDestinationSurface,CONST POINT* pDestPointsArray)
{
return m_pD3Ddev->CopyRects(pSourceSurface, pSourceRectsArray, cRects, pDestinationSurface, pDestPointsArray);
}

HRESULT APIENTRY hkIDirect3DDevice8::UpdateTexture(IDirect3DBaseTex ture8* pSourceTexture,IDirect3DBaseTexture8* pDestinationTexture)
{
return m_pD3Ddev->UpdateTexture(pSourceTexture, pDestinationTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetFrontBuffer(IDirect3DSurfac e8* pDestSurface)
{
return m_pD3Ddev->GetFrontBuffer(pDestSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetRenderTarget(IDirect3DSurfa ce8* pRenderTarget,IDirect3DSurface8* pNewZStencil)
{
return m_pD3Ddev->SetRenderTarget(pRenderTarget, pNewZStencil);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetRenderTarget(IDirect3DSurfa ce8** ppRenderTarget)
{
return m_pD3Ddev->GetRenderTarget(ppRenderTarget);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetDepthStencilSurface(IDirect 3DSurface8** ppZStencilSurface)
{
return m_pD3Ddev->GetDepthStencilSurface(ppZStencilSurface);
}

HRESULT APIENTRY hkIDirect3DDevice8::BeginScene(void)
//----------------------------------------------
//-----------ADD HACKS HERE---------------------
{
if( CH_Unlimammo ) // UNLIM AMMO!
{
D3D_NOPING( ( void* )ullammo_Addie1, 3);
D3D_NOPING( ( void* )ullammo_Addie2, 3);
D3D_NOPING( ( void* )ullammo_Addie3, 3);
}
{
if( CH_Boxs )//BOXS
{
D3D_NOPING( ( void* )boxs_Addie1, 1);
}
{
if( CH_Circles )//CIRCLES
{
D3D_NOPING( ( void* )circles_Addie1, 1);
}
//Add hack above here
{
return m_pD3Ddev->BeginScene();
}
}
}
} - You add this in as well!
//Add anouther } with every hack!

HRESULT APIENTRY hkIDirect3DDevice8::EndScene(void)

{
if (m_pFont_new)
m_pFont_new->DrawText(15.0f, 100.0f, txtRed, "RENAME ME D3D");//Rename Your Hack

if (m_pFont_INFO)
{
if (CH_Menu)
{
//-----------------------
//-------OK below here just copy ONE of the lines and change to the hack your adding!
sprintf(unlimammostring, "%s", (CH_Unlimammo ? "Unlim ammo ON" : "Unlim ammo OFF"));
sprintf(boxsstring, "%s", (CH_Boxs ? "Boxs ON" : "Boxs OFF"));
sprintf(circlesstring, "%s", (CH_Circles ? "Circles ON" : "Circles OFF"));

////--------------------------- this determines if the hack is highlighted -------------//
///--Same again Copy ONE of these and paste under the last one and change to your hack!
if(highlight[1]==1)
m_pFont_INFO->DrawText(15.0f, 120.0f, txtRed, unlimammostring);
else
m_pFont_INFO->DrawText(15.0f,120.0f, txtGreen, unlimammostring);

if(highlight[2]==1)
m_pFont_INFO->DrawText(15.0f, 130.0f, txtRed, boxsstring);
else
m_pFont_INFO->DrawText(15.0f,130.0f, txtGreen, boxsstring);

if(highlight[3]==2)
m_pFont_INFO->DrawText(15.0f, 140.0f, txtRed, circlesstring);
else
m_pFont_INFO->DrawText(15.0f,140.0f, txtGreen, circlesstring);

////-------------------------------------------------------------------------------------------------//

////------------------------This is how to use our menu ----------------------------------//

if(GetAsyncKeyState(VK_UP)&1)
{
//ADD +1 to were the 3 is so if its a new hack the 3 will be 4
for(int i=0; i < 3; i++)
{
if (highlight[i] == 1)
{
int a = i-1;

if(a < 1)
break;

else
{
highlight[a]=1;
highlight[i]=0;
break;
}
}
}
}

if(GetAsyncKeyState(VK_DOWN)&1)
{
for(int i=0; i < 3; i++) //Same again with the 3 add +1 with every hack!
{
if (highlight[i] == 1)
{
int a = i+1;

if(a > 2) //Same with the 2 add +1 with every hack
break;

else
{
highlight[a]=1;
highlight[i]=0;
break;
}
}
}
}

////------------------------ Activate hacks on/off here ------------------------------------//

if (GetAsyncKeyState(VK_INSERT)&1)
CH_Menu = !CH_Menu;
//--------------------------------------------------
//---Copy ONE of these and paste under the last!
//When adding a hack were the numbers are in the[*] Change it each time going in 1,2,3,4 and so on

if(highlight[1] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Unlimammo = !CH_Unlimammo;

if(highlight[2] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Boxs = !CH_Boxs;

if(highlight[3] == 1 && (GetAsyncKeyState(VK_RIGHT)&1))
CH_Circles = !CH_Circles;

//---------Paste above me!
//Once done hit Build then Rebuild to test for erros!
//Then build again and then Batch then rebuld all!
//Any errors then goto www.wr.ruworth.com
//Try to work them out b4 you do!
;}
}

return m_pD3Ddev->EndScene();
}

HRESULT APIENTRY hkIDirect3DDevice8::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 hkIDirect3DDevice8::SetTransform(D3DTRANSFORMSTATE TYPE State,CONST D3DMATRIX* pMatrix)
{
return m_pD3Ddev->SetTransform(State, pMatrix);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetTransform(D3DTRANSFORMSTATE TYPE State,D3DMATRIX* pMatrix)
{
return m_pD3Ddev->GetTransform(State, pMatrix);
}

HRESULT APIENTRY hkIDirect3DDevice8::MultiplyTransform( D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
{
return m_pD3Ddev->MultiplyTransform(State,pMatrix);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetViewport( CONST D3DVIEWPORT8* pViewport)
{
return m_pD3Ddev->SetViewport(pViewport);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetViewport( D3DVIEWPORT8* pViewport)
{
return m_pD3Ddev->GetViewport(pViewport);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetMaterial( CONST D3DMATERIAL8* pMaterial)
{
return m_pD3Ddev->SetMaterial(pMaterial);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetMaterial( D3DMATERIAL8* pMaterial)
{
return m_pD3Ddev->GetMaterial(pMaterial);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetLight( DWORD Index,CONST D3DLIGHT8* pLight)
{
return m_pD3Ddev->SetLight(Index,pLight);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetLight( DWORD Index,D3DLIGHT8* pLight)
{
return m_pD3Ddev->GetLight(Index,pLight);
}

HRESULT APIENTRY hkIDirect3DDevice8::LightEnable( DWORD Index,BOOL Enable)
{
return m_pD3Ddev->LightEnable(Index,Enable);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetLightEnable( DWORD Index,BOOL* pEnable)
{
return m_pD3Ddev->GetLightEnable(Index,pEnable);
}

HRESULT APIENTRY hkIDirect3DDevice8::Se***ipPlane( DWORD Index,CONST float* pPlane)
{
return m_pD3Ddev->Se***ipPlane(Index,pPlane);
}

HRESULT APIENTRY hkIDirect3DDevice8::Ge***ipPlane( DWORD Index,float* pPlane)
{
return m_pD3Ddev->Ge***ipPlane(Index,pPlane);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetRenderState( D3DRENDERSTATETYPE State,DWORD Value)
{
return m_pD3Ddev->SetRenderState(State,Value);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetRenderState( D3DRENDERSTATETYPE State,DWORD* pValue)
{
return m_pD3Ddev->GetRenderState(State,pValue);
}

HRESULT APIENTRY hkIDirect3DDevice8::BeginStateBlock(void)
{
return m_pD3Ddev->BeginStateBlock();
}

HRESULT APIENTRY hkIDirect3DDevice8::EndStateBlock( DWORD* pToken)
{
return m_pD3Ddev->EndStateBlock(pToken);
}

HRESULT APIENTRY hkIDirect3DDevice8::ApplyStateBlock( DWORD Token)
{
return m_pD3Ddev->ApplyStateBlock(Token);
}

HRESULT APIENTRY hkIDirect3DDevice8::CaptureStateBlock( DWORD Token)
{
return m_pD3Ddev->CaptureStateBlock(Token);
}

HRESULT APIENTRY hkIDirect3DDevice8:

eleteStateBlock( DWORD Token)
{
return m_pD3Ddev->DeleteStateBlock(Token);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateStateBlock( D3DSTATEBLOCKTYPE Type,DWORD* pToken)
{
return m_pD3Ddev->CreateStateBlock(Type,pToken);
}

HRESULT APIENTRY hkIDirect3DDevice8::Se***ipStatus( CONST D3DCLIPSTATUS8* pClipStatus)
{
return m_pD3Ddev->Se***ipStatus(pClipStatus);
}

HRESULT APIENTRY hkIDirect3DDevice8::Ge***ipStatus( D3DCLIPSTATUS8* pClipStatus)
{
return m_pD3Ddev->Ge***ipStatus(pClipStatus);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetTexture( DWORD Stage,IDirect3DBaseTexture8** ppTexture)
{
return m_pD3Ddev->GetTexture(Stage,ppTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetTexture(DWORD Stage,IDirect3DBaseTexture8* pTexture)
{
#ifdef D3DHOOK_TEXTURES
IDirect3DDevice8 *dev = NULL;
if(pTexture != NULL && ((hkIDirect3DTexture8*)(pTexture))->GetDevice(&dev) == D3D_OK)
{
if(dev == this)
return m_pD3Ddev->SetTexture(Stage, ((hkIDirect3DTexture8*)(pTexture))->m_D3Dtex);
}
#endif

return m_pD3Ddev->SetTexture(Stage,pTexture);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetTextureStageState( DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue)
{
return m_pD3Ddev->GetTextureStageState(Stage,Type,pValue);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetTextureStageState( DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value)
{
return m_pD3Ddev->SetTextureStageState(Stage,Type,Value);
}

HRESULT APIENTRY hkIDirect3DDevice8::ValidateDevice( DWORD* pNumPasses)
{
return m_pD3Ddev->ValidateDevice(pNumPasses);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetInfo( DWORD DevInfoID,void* pDevInfoStruct,DWORD DevInfoStructSize)
{
return m_pD3Ddev->GetInfo(DevInfoID,pDevInfoStruct,DevInfoStructSiz e);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetPaletteEntries( UINT PaletteNumber,CONST PALETTEENTRY* pEntries)
{
return m_pD3Ddev->SetPaletteEntries(PaletteNumber,pEntries);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries)
{
return m_pD3Ddev->GetPaletteEntries(PaletteNumber, pEntries);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetCurrentTexturePalette(UINT PaletteNumber)
{
return m_pD3Ddev->SetCurrentTexturePalette(PaletteNumber);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetCurrentTexturePalette(UINT *PaletteNumber)
{
return m_pD3Ddev->GetCurrentTexturePalette(PaletteNumber);
}

HRESULT APIENTRY hkIDirect3DDevice8:

rawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount)
{
return m_pD3Ddev->DrawPrimitive(PrimitiveType, StartVertex, PrimitiveCount);
}

HRESULT APIENTRY hkIDirect3DDevice8:

rawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT minIndex,UINT NumVertices,UINT startIndex,UINT primCount)
{
return m_pD3Ddev->DrawIndexedPrimitive(PrimitiveType, minIndex, NumVertices, startIndex, primCount);
}

HRESULT APIENTRY hkIDirect3DDevice8:

rawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawPrimitiveUP(PrimitiveType, PrimitiveCount, pVertexStreamZeroData, VertexStreamZeroStride);
}

HRESULT APIENTRY hkIDirect3DDevice8:

rawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertexIndices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
{
return m_pD3Ddev->DrawIndexedPrimitiveUP(PrimitiveType, MinVertexIndex, NumVertexIndices, PrimitiveCount, pIndexData, IndexDataFormat, pVertexStreamZeroData, VertexStreamZeroStride);
}

HRESULT APIENTRY hkIDirect3DDevice8::ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer8* pDestBuffer,DWORD Flags)
{
return m_pD3Ddev->ProcessVertices(SrcStartIndex, DestIndex, VertexCount, pDestBuffer, Flags);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreateVertexShader(CONST DWORD* pDeclaration,CONST DWORD* pFunction,DWORD* pHandle,DWORD Usage)
{
return m_pD3Ddev->CreateVertexShader(pDeclaration, pFunction, pHandle, Usage);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetVertexShader(DWORD Handle)
{
return m_pD3Ddev->SetVertexShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShader(DWORD* pHandle)
{
return m_pD3Ddev->GetVertexShader(pHandle);
}

HRESULT APIENTRY hkIDirect3DDevice8:

eleteVertexShader(DWORD Handle)
{
return m_pD3Ddev->DeleteVertexShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetVertexShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->SetVertexShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->GetVertexShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShaderDeclaration(DWO RD Handle,void* pData,DWORD* pSizeOfData)
{
return m_pD3Ddev->GetVertexShaderDeclaration(Handle, pData, pSizeOfData);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetVertexShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData)
{
return m_pD3Ddev->GetVertexShaderFunction(Handle, pData, pSizeOfData);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8* pStreamData,UINT Stride)
{
return m_pD3Ddev->SetStreamSource(StreamNumber, pStreamData, Stride);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer8** ppStreamData,UINT* pStride)
{
return m_pD3Ddev->GetStreamSource(StreamNumber, ppStreamData, pStride);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetIndices(IDirect3DIndexBuffe r8* pIndexData,UINT BaseVertexIndex)
{
return m_pD3Ddev->SetIndices(pIndexData, BaseVertexIndex);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetIndices(IDirect3DIndexBuffe r8** ppIndexData,UINT* pBaseVertexIndex)
{
return m_pD3Ddev->GetIndices(ppIndexData, pBaseVertexIndex);
}

HRESULT APIENTRY hkIDirect3DDevice8::CreatePixelShader(CONST DWORD* pFunction,DWORD* pHandle)
{
return m_pD3Ddev->CreatePixelShader(pFunction, pHandle);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetPixelShader(DWORD Handle)
{
return m_pD3Ddev->SetPixelShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPixelShader(DWORD* pHandle)
{
return m_pD3Ddev->GetPixelShader(pHandle);
}

HRESULT APIENTRY hkIDirect3DDevice8:

eletePixelShader(DWORD Handle)
{
return m_pD3Ddev->DeletePixelShader(Handle);
}

HRESULT APIENTRY hkIDirect3DDevice8::SetPixelShaderConstant(DWORD Register,CONST void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->SetPixelShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPixelShaderConstant(DWORD Register,void* pConstantData,DWORD ConstantCount)
{
return m_pD3Ddev->GetPixelShaderConstant(Register, pConstantData, ConstantCount);
}

HRESULT APIENTRY hkIDirect3DDevice8::GetPixelShaderFunction(DWORD Handle,void* pData,DWORD* pSizeOfData)
{
return m_pD3Ddev->GetPixelShaderFunction(Handle, pData, pSizeOfData);
}

HRESULT APIENTRY hkIDirect3DDevice8:

rawRectPatch(UINT Handle,CONST float* pNumSegs,CONST D3DRECTPATCH_INFO* pRectPatchInfo)
{
return m_pD3Ddev->DrawRectPatch(Handle, pNumSegs, pRectPatchInfo);
}

HRESULT APIENTRY hkIDirect3DDevice8:

rawTriPatch(UINT Handle,CONST float* pNumSegs,CONST D3DTRIPATCH_INFO* pTriPatchInfo)
{
return m_pD3Ddev->DrawTriPatch(Handle, pNumSegs, pTriPatchInfo);
}

HRESULT APIENTRY hkIDirect3DDevice8:

eletePatch(UINT Handle)
{
return m_pD3Ddev->DeletePatch(Handle);
}

-----------------------------------------------------

this is my source what have i done wronge

add my msn : kylegyoles@msn.com
or my xfire : kyleownzyou

PLEASE HELp!!!!!!!!!!!!!!!!!!!!!!!

Warrock D3D TuT!

Post a Reply

Similar Threads

Tags for this Thread