Page 1 of 2 12 LastLast
Results 1 to 15 of 19
  1. 06-17-2011 #1
    AeroSkinn
    AeroSkinn is offline
    Banned
    BANNED!
    AeroSkinn's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    33
    Reputation
    10
    Thanks
    4
    My Mood
    Amused
    Send a message via Birdie™ to AeroSkinn United States

    Create your first D3D menu for WarRock

    Welcome to a tut made by AeroSkinn.

    This is full writed by me AeroSkinn.
    If you leech please include credits:

    Karrka -> Base
    Detours ->Croner
    AeroSkinn -> Teacher

    First we start with the basic menu:
    Create in C++: Detour Filter

    [CENTER]ADE32.h
    Code:
    #ifndef __ADE32_H__
#define __ADE32_H__

#define C_ERROR		0xFFFFFFFF
#define C_ADDR1		0x00000001
#define C_ADDR2		0x00000002
#define C_ADDR4		0x00000004
#define C_LOCK		0x00000008
#define C_67		0x00000010
#define C_66		0x00000020
#define C_REP		0x00000040
#define C_SEG		0x00000080
#define C_ANYPREFIX	(C_66+C_67+C_LOCK+C_REP+C_SEG)
#define C_DATA1		0x00000100
#define C_DATA2		0x00000200
#define C_DATA4		0x00000400
#define C_SIB		0x00000800
#define C_ADDR67	0x00001000
#define C_DATA66	0x00002000
#define C_MODRM		0x00004000
#define C_BAD		0x00008000
#define C_OPCODE2	0x00010000
#define C_REL		0x00020000
#define C_STOP		0x00040000

#pragma pack(push)
#pragma pack(1)

struct disasm_struct 
{
	BYTE disasm_defaddr;	// 00
	BYTE disasm_defdata;	// 01
	DWORD disasm_len;		// 02 03 04 05
	DWORD disasm_flag;		// 06 07 08 09
	DWORD disasm_addrsize;	// 0A 0B 0C 0D
	DWORD disasm_datasize;	// 0E 0F 10 11
	BYTE disasm_rep;		// 12
	BYTE disasm_seg;		// 13
	BYTE disasm_opcode;		// 14
	BYTE disasm_opcode2;	// 15
	BYTE disasm_modrm;		// 16
	BYTE disasm_sib;		// 17

	union 
	{
		BYTE disasm_addr_b[8];	// 18 19 1A 1B  1C 1D 1E 1F
		WORD disasm_addr_w[4];
		DWORD disasm_addr_d[2];
		char disasm_addr_c[8];
		short disasm_addr_s[4];
		long disasm_addr_l[2];
	};

	union 
	{
		BYTE disasm_data_b[8];	// 20 21 22 23  24 25 26 27
		WORD disasm_data_w[4];
		DWORD disasm_data_d[2];
		char disasm_data_c[8];
		short disasm_data_s[4];
		long disasm_data_l[2];
	};
}; // disasm_struct

#pragma pack(pop)

int disasm(BYTE* opcode0, disasm_struct* diza);
int oplen(BYTE* opcode);

#endif // __ADE32_H__
    detour.h
    Code:
    #define JUNK_CODE_ONE          \
    __asm{push eax}            \
    __asm{xor eax, eax}        \
    __asm{setpo al}            \
    __asm{push edx}            \
    __asm{xor edx, eax}        \
    __asm{sal edx, 2}          \
    __asm{xchg eax, edx}       \
    __asm{pop edx}             \
    __asm{or eax, ecx}         \
    __asm{pop eax}

DWORD DetourMePleaseImNice( DWORD  SrcVA, DWORD  DstVA, DWORD  Size )
{
	DWORD DetourVA, dwProtect, i;

#define SIZEOF_MOVEAX_JMPEAX 7
	JUNK_CODE_ONE
	if ( SrcVA && DstVA && Size >= SIZEOF_MOVEAX_JMPEAX )
	{
		JUNK_CODE_ONE
		DetourVA = (DWORD)VirtualAlloc( NULL, Size + SIZEOF_MOVEAX_JMPEAX, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

		if ( DetourVA && VirtualProtectEx(GetCurrentProcess(),(void*)SrcVA, Size, PAGE_READWRITE, &dwProtect ))
		{
			JUNK_CODE_ONE
			for ( i=0; i < Size; i++ ) {
				JUNK_CODE_ONE
				*(BYTE*)( DetourVA + i ) = *(BYTE*)( SrcVA + i );
				JUNK_CODE_ONE
			}
			JUNK_CODE_ONE
			*(BYTE*)( DetourVA + Size + 0 ) = 0xB8;
			JUNK_CODE_ONE
			*(DWORD*)( DetourVA + Size + 1 ) = ( SrcVA + Size );
			JUNK_CODE_ONE
			*(WORD*)( DetourVA + Size + 5 ) = 0xE0FF;
			JUNK_CODE_ONE

			*(BYTE*)( SrcVA + 0 ) = 0xB8;
			JUNK_CODE_ONE
			*(DWORD*)( SrcVA + 1 ) = ( DstVA );
			JUNK_CODE_ONE
			*(WORD*)( SrcVA + 5 ) = 0xE0FF;
			JUNK_CODE_ONE

			VirtualProtectEx(GetCurrentProcess(),(void*)SrcVA, Size, dwProtect, &dwProtect );
			JUNK_CODE_ONE
			VirtualProtectEx(GetCurrentProcess(),(void*)DetourVA, Size + SIZEOF_MOVEAX_JMPEAX, PAGE_EXECUTE_READ, &dwProtect);
			JUNK_CODE_ONE
	    	return DetourVA;
		}
	}
	return 0;
}

DWORD DetourCreateE9( DWORD  SrcVA, DWORD  DstVA, DWORD  Size )
{

DWORD DetourVA, dwProtect, i;

#define SIZEOF_JMP_REL 5

if ( SrcVA && DstVA && Size >= SIZEOF_JMP_REL )
{
DetourVA = (DWORD) VirtualAlloc( 
NULL, Size + SIZEOF_JMP_REL, 
MEM_COMMIT, PAGE_EXECUTE_READWRITE );

if ( DetourVA && VirtualProtect( (VOID*)SrcVA, Size, PAGE_EXECUTE_READWRITE, &dwProtect ) )
{
for ( i=0; i < Size; i++ ) {
*(BYTE*)( DetourVA + i ) = *(BYTE*)( SrcVA + i );
}

*(BYTE*)( DetourVA + Size + 0 ) = 0xE9;
*(DWORD*)( DetourVA + Size + 1 ) = ( SrcVA - DetourVA - SIZEOF_JMP_REL );

*(BYTE*)( SrcVA + 0 ) = 0xE9;
*(DWORD*)( SrcVA + 1 ) = ( DstVA - SrcVA - SIZEOF_JMP_REL );

VirtualProtect( (VOID*)SrcVA, Size, dwProtect, &dwProtect );

VirtualProtect( (VOID*)DetourVA, Size + 
SIZEOF_JMP_REL, PAGE_EXECUTE_READ, &dwProtect );

return DetourVA;
}
}
return (0);
}
    pattern.h
    Code:
     BOOL bCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
	for(;*szMask;++szMask,++pData,++bMask)
		if(*szMask=='x' && *pData!=*bMask) 
			return false;
	return (*szMask) == NULL;
}

DWORD FindPattern(DWORD dwAddress,DWORD dwLen,BYTE *bMask,char * szMask)
{
	for(DWORD i=0; i < dwLen; i++)
		if( bCompare((BYTE*)(dwAddress+i),bMask,szMask))
			return (DWORD)(dwAddress+i);
	return 0;
}
    StdAfx.h
    Code:
    #if!defined __STDAFX_H__
#define __STDAFX_H__

#define WIN32_LEAN_AND_MEAN
#pragma comment(lib,"d3dx9.lib")
#include <windows.h>
#include <winsock.h>
#include <d3dx9.h>
#include <d3d9.h>

#endif
    d3dfont.h
    Code:
     #ifndef _D3DFONT_H_
#define _D3DFONT_H_

#include <tchar.h>
#include <d3d9.h>

// Font creation flags
#define D3DFONT_BOLD        0x0001
#define D3DFONT_ITALIC      0x0002
#define D3DFONT_ZENABLE     0x0004

// Font rendering flags
#define D3DFONT_CENTERED    0x0001
#define D3DFONT_TWOSIDED    0x0002
#define D3DFONT_FILTERED    0x0004
#define D3DFONT_RIGHT       0x0008			// non standard feature
#define D3DFONT_SHADOW      0x0010			// non standard feature

//-----------------------------------------------------------------------------
// Name: class CD3DFont
// Desc: Texture-based font class for doing text in a 3D scene.
//-----------------------------------------------------------------------------
class CD3DFont
{
    TCHAR   m_strFontName[80];            // Font properties
    DWORD   m_dwFontHeight;
    DWORD   m_dwFontFlags;

    LPDIRECT3DDEVICE9       m_pd3dDevice; // A D3DDevice used for rendering
    LPDIRECT3DTEXTURE9      m_pTexture;   // The d3d texture for this font
    LPDIRECT3DVERTEXBUFFER9 m_pVB;        // VertexBuffer for rendering text
    DWORD   m_dwTexWidth;                 // Texture dimensions
    DWORD   m_dwTexHeight;
    FLOAT   m_fTextScale;
    FLOAT   m_fTexCoords[128-32][4];
    DWORD   m_dwSpacing;                  // Character pixel spacing per side

    // Stateblocks for setting and restoring render states
    LPDIRECT3DSTATEBLOCK9 m_pStateBlockSaved;
    LPDIRECT3DSTATEBLOCK9 m_pStateBlockDrawText;

public:
    // 2D and 3D text drawing functions
    HRESULT DrawText( FLOAT x, FLOAT y, DWORD dwColor, 
                      const TCHAR* strText, DWORD dwFlags=0L );
    HRESULT DrawTextScaled( FLOAT x, FLOAT y, FLOAT z, 
                            FLOAT fXScale, FLOAT fYScale, DWORD dwColor, 
                            const TCHAR* strText, DWORD dwFlags=0L );
    HRESULT Render3DText( const TCHAR* strText, DWORD dwFlags=0L );
    
    // Function to get extent of text
    HRESULT GetTextExtent( const TCHAR* strText, SIZE* pSize );

    // Initializing and destroying device-dependent objects
    HRESULT InitDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice );
    HRESULT RestoreDeviceObjects();
    HRESULT InvalidateDeviceObjects();
    HRESULT DeleteDeviceObjects();

    // Constructor / destructor
    CD3DFont( const TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags=0L );
    ~CD3DFont();
};

#endif// _D3DFONT_H_
    hsmethode.h
    Code:
    #pragma warning(disable:4102)
    int.h
    Code:
     bool Create;
    main.h
    Code:
    #ifndef _MAIN_H_
#define _MAIN_H_


typedef HRESULT ( WINAPI* oPresent ) ( LPDIRECT3DDEVICE9 pDevice, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
oPresent pPresent;

typedef HRESULT (WINAPI* oReset) (LPDIRECT3DDEVICE9 pDevice, D3DPRESENT_PARAMETERS* pPresentationParameters);
oReset pReset;

typedef HRESULT (WINAPI* oDrawIndexedPrimitive) (LPDIRECT3DDEVICE9 pDevice, D3DPRIMITIVETYPE Type, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount);
oDrawIndexedPrimitive pDrawIndexedPrimitive;

typedef HRESULT (WINAPI* oEndScene) (LPDIRECT3DDEVICE9 pDevice);
oEndScene pEndScene;

PVOID D3Ddiscover(void *tbl, int size)
{
	HWND hWnd;
	void *pInterface=0 ;
	D3DPRESENT_PARAMETERS d3dpp; 

	if ((hWnd=CreateWindowEx(NULL,WC_DIALOG,"",WS_OVERLAPPED,0,0,50,50,NULL,NULL,NULL,NULL))==NULL) return 0;
	ShowWindow(hWnd, SW_HIDE);

	LPDIRECT3D9			pD3D;
	LPDIRECT3DDEVICE9	pD3Ddev;
	if ((pD3D = Direct3DCreate9(D3D_SDK_VERSION))!=NULL) 
	{
	    ZeroMemory(&d3dpp, sizeof(d3dpp));
	    d3dpp.Windowed         = TRUE;
		d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
	    d3dpp.hDeviceWindow    = hWnd;
	    d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
	    d3dpp.BackBufferWidth  = d3dpp.BackBufferHeight = 600;
		pD3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&d3dpp,&pD3Ddev);
		if (pD3Ddev)  
		{
		    pInterface = (PDWORD)*(DWORD *)pD3Ddev;
			memcpy(tbl,(void *)pInterface,size);
			pD3Ddev->Release();
		}
		pD3D->Release();
	}
	DestroyWindow(hWnd);
	return pInterface;
}

#endif// _MAIN_H_
    color.h
    Code:
     #ifndef _COLOR_H_
#define _COLOR_H_

#define WHITE	D3DCOLOR_ARGB(255, 255, 255, 255)
#define RED		D3DCOLOR_ARGB(255, 255, 000, 000)
#define GREEN	D3DCOLOR_ARGB(175, 000, 230, 000)
#define BLUE	D3DCOLOR_ARGB(255, 000, 000, 255) 
#define BLACK	D3DCOLOR_ARGB(128, 000, 000, 000)
//#define BLACK	D3DCOLOR_ARGB(255, 000, 000, 000)
#define BLACK2	D3DCOLOR_ARGB(255, 000, 000, 000)
#define PURPLE	D3DCOLOR_ARGB(255, 125, 000, 255) 
#define GREY	D3DCOLOR_ARGB(128, 128, 128, 128) 
#define YELLOW	D3DCOLOR_ARGB(255, 255, 255, 000) 
#define ORANGE	D3DCOLOR_ARGB(255, 255, 125, 000)
#define CYAN	D3DCOLOR_ARGB(255, 000, 139 ,200)
#define PINK    D3DCOLOR_ARGB(255,255,192,203)
//#define BlackTrans D3DCOLOR_ARGB(175,000,000,000)
#define BlackTrans D3DCOLOR_ARGB(128, 0, 0, 0)
#define GhostWHITE	D3DCOLOR_ARGB(175, 175, 175, 175)
#define GhostRED		D3DCOLOR_ARGB(175, 100, 000, 000)
#define GhostCYANS	D3DCOLOR_ARGB(175,000,255,255);
#define GhostGREEN	D3DCOLOR_ARGB(175, 000, 175, 000)
#define GhostBLUE	D3DCOLOR_ARGB(175, 000, 000, 175) 
#define GhostBLACK	D3DCOLOR_ARGB(70, 000, 000, 000)
#define GhostBLACK	D3DCOLOR_ARGB(45, 000, 000, 100)
#define GhostPURPLE	D3DCOLOR_ARGB(175, 60, 000, 175) 
#define GhostGREY	D3DCOLOR_ARGB(175, 59, 59, 59) 
#define GhostYELLOW	D3DCOLOR_ARGB(175, 175, 175, 000) 
#define GhostORANGE	D3DCOLOR_ARGB(175, 175, 175, 000)
#define GhostCYAN	D3DCOLOR_ARGB(175, 000, 64 ,200)
#define GhostPINK   D3DCOLOR_ARGB(175,175,91,117)
#define BlackMenuz D3DCOLOR_ARGB(125,0,0,0)
#define Brent      D3DCOLOR_ARGB(128,246,64,132)
#endif // _COLOR_H_
    d3dmenu.h
    Code:
    #ifndef _D3DMENU_H_
#define _D3DMENU_H_

#include <windows.h>
#include "d3dfont.h"
#include <d3dx9.h>
#include "Color.h"

#define MENUFOLDER 1
#define MENUTEXT   2
#define MENUITEM   3
#define SUBFOLDER  4

#define White          D3DCOLOR_ARGB(255,255,255,255) 
#define Red            D3DCOLOR_ARGB(255,255,0,0) 
#define Green          D3DCOLOR_ARGB(255,0,255,0)
#define Blue           D3DCOLOR_ARGB(255,0,0,255)
#define Black          D3DCOLOR_ARGB(255,0,0,0)
#define Purple         D3DCOLOR_ARGB(255,125,0,255)
#define Grey           D3DCOLOR_ARGB(255,128,128,128)
#define Yellow         D3DCOLOR_ARGB(255,255,255,0)
#define Orange         D3DCOLOR_ARGB(255,255,140,0)
#define Cyan           D3DCOLOR_ARGB(255,0,139,200)
#define Pink           D3DCOLOR_ARGB(255,255,192,203)
#define LightBlue      D3DCOLOR_ARGB(255, 66, 180, 230)
#define Brent          D3DCOLOR_ARGB(128,246,64,132)

#define menu_on		 Blue
#define menu_off	 White
#define menu_folder	 Red
#define menu_text	 Brent
#define menu_current Green

typedef struct
{
	int  typ;
	char *txt;
	char **opt;
	int  *var;
	int  maxval;
}tMENU;

class D3DMenu
{
public:
	D3DMenu(char *Name=0, int maxentries=130, int maxwidth=300)
	{
		title = Name;
		maxitems = maxentries;
		cur = noitems = visible = 0;
		x = 28;
		y = 30;
		totwidth = ofs = maxwidth;
		height = 12;
		titleheight = totheight = height+4;
		col_group   = menu_folder;
		col_text    = menu_text;
		col_off     = menu_off;
		col_on      = menu_on;
		col_current = menu_current;
		MENU=(tMENU **)malloc(4*maxitems);
		for (int i=0; i<maxitems; i++) MENU[i]=(tMENU *)malloc(sizeof(tMENU));
	}
	~D3DMenu(){
		for (int i=0; i<maxitems; i++) free(MENU[i]);
		free(MENU);
	}

	DWORD col_title;
	DWORD col_group;
	DWORD col_group1;
	DWORD col_text;
	DWORD col_off;
	DWORD col_on;
	DWORD col_current;

	int x,y;
	int totwidth,totheight;
	int height;
	int titleheight;
	int ofs;
	int max_x, max_y;
	int m_x,m_y;
	int m_lm, m_rm;
	char *title;
	int cur;
	int noitems;
	int visible;
	int moving;

	tMENU **MENU;

	// Load Save Menu
	void Save(char* szSection, char* szKey, int iValue);
	int  Load(char* szSection, char* szKey, int iDefaultValue);
	void AddItem  (char *txt, int *var, char **opt, int maxvalue=2, int typ=MENUITEM);
	void AddGroup (char *txt, int *var, char **opt, int maxvalue=2);
	void AddSubb  (char *txt, int *var, char **opt, int maxvalue=2);
	void AddText  (char *txt, char *opt="");
	void Show     (ID3DXFont *pFont1,LPDIRECT3DDEVICE9 pDevice);
	void Nav      (void);
	void CheckTitleMove(int rm,int mx, int my);
	void DrawTextC(int x,int y,DWORD color,char *text, ID3DXFont*  pFont);

private:
	int	maxitems;
	int dx,dy;
	int FindItem(void);

};

#endif// _D3DMENU_H_
    addies.h
    Code:
     #include <math.h>

#define HackFuctions(Type,Adr,Vaule)	*(Type*)(Adr) = Vaule;
#define WARROCK decrypt("`j{[xlt")
    ADE32.cpp
    Code:
     // ADE32 version 2.02c -- C edition

#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN

#include <windows.h>
#include "ADE32.h"

DWORD ade32_table[512] = {
/* 00 */  C_MODRM,
/* 01 */  C_MODRM,
/* 02 */  C_MODRM,
/* 03 */  C_MODRM,
/* 04 */  C_DATA1,
/* 05 */  C_DATA66,
/* 06 */  C_BAD,
/* 07 */  C_BAD,
/* 08 */  C_MODRM,
/* 09 */  C_MODRM,
/* 0A */  C_MODRM,
/* 0B */  C_MODRM,
/* 0C */  C_DATA1,
/* 0D */  C_DATA66,
/* 0E */  C_BAD,
/* 0F */  C_OPCODE2,
/* 10 */  C_MODRM+C_BAD,
/* 11 */  C_MODRM,
/* 12 */  C_MODRM+C_BAD,
/* 13 */  C_MODRM,
/* 14 */  C_DATA1+C_BAD,
/* 15 */  C_DATA66+C_BAD,
/* 16 */  C_BAD,
/* 17 */  C_BAD,
/* 18 */  C_MODRM+C_BAD,
/* 19 */  C_MODRM,
/* 1A */  C_MODRM,
/* 1B */  C_MODRM,
/* 1C */  C_DATA1+C_BAD,
/* 1D */  C_DATA66+C_BAD,
/* 1E */  C_BAD,
/* 1F */  C_BAD,
/* 20 */  C_MODRM,
/* 21 */  C_MODRM,
/* 22 */  C_MODRM,
/* 23 */  C_MODRM,
/* 24 */  C_DATA1,
/* 25 */  C_DATA66,
/* 26 */  C_SEG+C_BAD,
/* 27 */  C_BAD,
/* 28 */  C_MODRM,
/* 29 */  C_MODRM,
/* 2A */  C_MODRM,
/* 2B */  C_MODRM,
/* 2C */  C_DATA1,
/* 2D */  C_DATA66,
/* 2E */  C_SEG+C_BAD,
/* 2F */  C_BAD,
/* 30 */  C_MODRM,
/* 31 */  C_MODRM,
/* 32 */  C_MODRM,
/* 33 */  C_MODRM,
/* 34 */  C_DATA1,
/* 35 */  C_DATA66,
/* 36 */  C_SEG+C_BAD,
/* 37 */  C_BAD,
/* 38 */  C_MODRM,
/* 39 */  C_MODRM,
/* 3A */  C_MODRM,
/* 3B */  C_MODRM,
/* 3C */  C_DATA1,
/* 3D */  C_DATA66,
/* 3E */  C_SEG+C_BAD,
/* 3F */  C_BAD,
/* 40 */  0,
/* 41 */  0,
/* 42 */  0,
/* 43 */  0,
/* 44 */  C_BAD,
/* 45 */  0,
/* 46 */  0,
/* 47 */  0,
/* 48 */  0,
/* 49 */  0,
/* 4A */  0,
/* 4B */  0,
/* 4C */  C_BAD,
/* 4D */  0,
/* 4E */  0,
/* 4F */  0,
/* 50 */  0,
/* 51 */  0,
/* 52 */  0,
/* 53 */  0,
/* 54 */  0,
/* 55 */  0,
/* 56 */  0,
/* 57 */  0,
/* 58 */  0,
/* 59 */  0,
/* 5A */  0,
/* 5B */  0,
/* 5C */  C_BAD,
/* 5D */  0,
/* 5E */  0,
/* 5F */  0,
/* 60 */  C_BAD,
/* 61 */  C_BAD,
/* 62 */  C_MODRM+C_BAD,
/* 63 */  C_MODRM+C_BAD,
/* 64 */  C_SEG,
/* 65 */  C_SEG+C_BAD,
/* 66 */  C_66,
/* 67 */  C_67,
/* 68 */  C_DATA66,
/* 69 */  C_MODRM+C_DATA66,
/* 6A */  C_DATA1,
/* 6B */  C_MODRM+C_DATA1,
/* 6C */  C_BAD,
/* 6D */  C_BAD,
/* 6E */  C_BAD,
/* 6F */  C_BAD,
/* 70 */  C_DATA1+C_REL+C_BAD,
/* 71 */  C_DATA1+C_REL+C_BAD,
/* 72 */  C_DATA1+C_REL,
/* 73 */  C_DATA1+C_REL,
/* 74 */  C_DATA1+C_REL,
/* 75 */  C_DATA1+C_REL,
/* 76 */  C_DATA1+C_REL,
/* 77 */  C_DATA1+C_REL,
/* 78 */  C_DATA1+C_REL,
/* 79 */  C_DATA1+C_REL,
/* 7A */  C_DATA1+C_REL+C_BAD,
/* 7B */  C_DATA1+C_REL+C_BAD,
/* 7C */  C_DATA1+C_REL,
/* 7D */  C_DATA1+C_REL,
/* 7E */  C_DATA1+C_REL,
/* 7F */  C_DATA1+C_REL,
/* 80 */  C_MODRM+C_DATA1,
/* 81 */  C_MODRM+C_DATA66,
/* 82 */  C_MODRM+C_DATA1+C_BAD,
/* 83 */  C_MODRM+C_DATA1,
/* 84 */  C_MODRM,
/* 85 */  C_MODRM,
/* 86 */  C_MODRM,
/* 87 */  C_MODRM,
/* 88 */  C_MODRM,
/* 89 */  C_MODRM,
/* 8A */  C_MODRM,
/* 8B */  C_MODRM,
/* 8C */  C_MODRM+C_BAD,
/* 8D */  C_MODRM,
/* 8E */  C_MODRM+C_BAD,
/* 8F */  C_MODRM,
/* 90 */  0,
/* 91 */  0,
/* 92 */  0,
/* 93 */  C_BAD,
/* 94 */  C_BAD,
/* 95 */  C_BAD,
/* 96 */  C_BAD,
/* 97 */  C_BAD,
/* 98 */  C_BAD,
/* 99 */  0,
/* 9A */  C_DATA66+C_DATA2+C_BAD,
/* 9B */  0,
/* 9C */  C_BAD,
/* 9D */  C_BAD,
/* 9E */  C_BAD,
/* 9F */  C_BAD,
/* A0 */  C_ADDR67,
/* A1 */  C_ADDR67,
/* A2 */  C_ADDR67,
/* A3 */  C_ADDR67,
/* A4 */  0,
/* A5 */  0,
/* A6 */  0,
/* A7 */  0,
/* A8 */  C_DATA1,
/* A9 */  C_DATA66,
/* AA */  0,
/* AB */  0,
/* AC */  0,
/* AD */  C_BAD,
/* AE */  0,
/* AF */  C_BAD,
/* B0 */  C_DATA1,
/* B1 */  C_DATA1,
/* B2 */  C_DATA1,
/* B3 */  C_DATA1,
/* B4 */  C_DATA1,
/* B5 */  C_DATA1,
/* B6 */  C_DATA1+C_BAD,
/* B7 */  C_DATA1+C_BAD,
/* B8 */  C_DATA66,
/* B9 */  C_DATA66,
/* BA */  C_DATA66,
/* BB */  C_DATA66,
/* BC */  C_DATA66+C_BAD,
/* BD */  C_DATA66,
/* BE */  C_DATA66,
/* BF */  C_DATA66,
/* C0 */  C_MODRM+C_DATA1,
/* C1 */  C_MODRM+C_DATA1,
/* C2 */  C_DATA2+C_STOP,
/* C3 */  C_STOP,
/* C4 */  C_MODRM+C_BAD,
/* C5 */  C_MODRM+C_BAD,
/* C6 */  C_MODRM+C_DATA1,
/* C7 */  C_MODRM+C_DATA66,
/* C8 */  C_DATA2+C_DATA1,
/* C9 */  0,
/* CA */  C_DATA2+C_STOP+C_BAD,
/* CB */  C_STOP+C_BAD,
/* CC */  C_BAD,
/* CD */  C_BAD,
/* CE */  C_BAD,
/* CF */  C_STOP+C_BAD,
/* D0 */  C_MODRM,
/* D1 */  C_MODRM,
/* D2 */  C_MODRM,
/* D3 */  C_MODRM,
/* D4 */  C_DATA1+C_BAD,
/* D5 */  C_DATA1+C_BAD,
/* D6 */  C_BAD,
/* D7 */  C_BAD,
/* D8 */  C_MODRM,
/* D9 */  C_MODRM,
/* DA */  C_MODRM,
/* DB */  C_MODRM,
/* DC */  C_MODRM,
/* DD */  C_MODRM,
/* DE */  C_MODRM,
/* DF */  C_MODRM,
/* E0 */  C_DATA1+C_REL+C_BAD,
/* E1 */  C_DATA1+C_REL+C_BAD,
/* E2 */  C_DATA1+C_REL,
/* E3 */  C_DATA1+C_REL,
/* E4 */  C_DATA1+C_BAD,
/* E5 */  C_DATA1+C_BAD,
/* E6 */  C_DATA1+C_BAD,
/* E7 */  C_DATA1+C_BAD,
/* E8 */  C_DATA66+C_REL,
/* E9 */  C_DATA66+C_REL+C_STOP,
/* EA */  C_DATA66+C_DATA2+C_BAD,
/* EB */  C_DATA1+C_REL+C_STOP,
/* EC */  C_BAD,
/* ED */  C_BAD,
/* EE */  C_BAD,
/* EF */  C_BAD,
/* F0 */  C_LOCK+C_BAD,
/* F1 */  C_BAD,
/* F2 */  C_REP,
/* F3 */  C_REP,
/* F4 */  C_BAD,
/* F5 */  C_BAD,
/* F6 */  C_MODRM,
/* F7 */  C_MODRM,
/* F8 */  0,
/* F9 */  0,
/* FA */  C_BAD,
/* FB */  C_BAD,
/* FC */  0,
/* FD */  0,
/* FE */  C_MODRM,
/* FF */  C_MODRM,
/* 00 */  C_MODRM,
/* 01 */  C_MODRM,
/* 02 */  C_MODRM,
/* 03 */  C_MODRM,
/* 04 */  C_ERROR,
/* 05 */  C_ERROR,
/* 06 */  0,
/* 07 */  C_ERROR,
/* 08 */  0,
/* 09 */  0,
/* 0A */  0,
/* 0B */  0,
/* 0C */  C_ERROR,
/* 0D */  C_ERROR,
/* 0E */  C_ERROR,
/* 0F */  C_ERROR,
/* 10 */  C_ERROR,
/* 11 */  C_ERROR,
/* 12 */  C_ERROR,
/* 13 */  C_ERROR,
/* 14 */  C_ERROR,
/* 15 */  C_ERROR,
/* 16 */  C_ERROR,
/* 17 */  C_ERROR,
/* 18 */  C_ERROR,
/* 19 */  C_ERROR,
/* 1A */  C_ERROR,
/* 1B */  C_ERROR,
/* 1C */  C_ERROR,
/* 1D */  C_ERROR,
/* 1E */  C_ERROR,
/* 1F */  C_ERROR,
/* 20 */  C_ERROR,
/* 21 */  C_ERROR,
/* 22 */  C_ERROR,
/* 23 */  C_ERROR,
/* 24 */  C_ERROR,
/* 25 */  C_ERROR,
/* 26 */  C_ERROR,
/* 27 */  C_ERROR,
/* 28 */  C_ERROR,
/* 29 */  C_ERROR,
/* 2A */  C_ERROR,
/* 2B */  C_ERROR,
/* 2C */  C_ERROR,
/* 2D */  C_ERROR,
/* 2E */  C_ERROR,
/* 2F */  C_ERROR,
/* 30 */  C_ERROR,
/* 31 */  C_ERROR,
/* 32 */  C_ERROR,
/* 33 */  C_ERROR,
/* 34 */  C_ERROR,
/* 35 */  C_ERROR,
/* 36 */  C_ERROR,
/* 37 */  C_ERROR,
/* 38 */  C_ERROR,
/* 39 */  C_ERROR,
/* 3A */  C_ERROR,
/* 3B */  C_ERROR,
/* 3C */  C_ERROR,
/* 3D */  C_ERROR,
/* 3E */  C_ERROR,
/* 3F */  C_ERROR,
/* 40 */  C_ERROR,
/* 41 */  C_ERROR,
/* 42 */  C_ERROR,
/* 43 */  C_ERROR,
/* 44 */  C_ERROR,
/* 45 */  C_ERROR,
/* 46 */  C_ERROR,
/* 47 */  C_ERROR,
/* 48 */  C_ERROR,
/* 49 */  C_ERROR,
/* 4A */  C_ERROR,
/* 4B */  C_ERROR,
/* 4C */  C_ERROR,
/* 4D */  C_ERROR,
/* 4E */  C_ERROR,
/* 4F */  C_ERROR,
/* 50 */  C_ERROR,
/* 51 */  C_ERROR,
/* 52 */  C_ERROR,
/* 53 */  C_ERROR,
/* 54 */  C_ERROR,
/* 55 */  C_ERROR,
/* 56 */  C_ERROR,
/* 57 */  C_ERROR,
/* 58 */  C_ERROR,
/* 59 */  C_ERROR,
/* 5A */  C_ERROR,
/* 5B */  C_ERROR,
/* 5C */  C_ERROR,
/* 5D */  C_ERROR,
/* 5E */  C_ERROR,
/* 5F */  C_ERROR,
/* 60 */  C_ERROR,
/* 61 */  C_ERROR,
/* 62 */  C_ERROR,
/* 63 */  C_ERROR,
/* 64 */  C_ERROR,
/* 65 */  C_ERROR,
/* 66 */  C_ERROR,
/* 67 */  C_ERROR,
/* 68 */  C_ERROR,
/* 69 */  C_ERROR,
/* 6A */  C_ERROR,
/* 6B */  C_ERROR,
/* 6C */  C_ERROR,
/* 6D */  C_ERROR,
/* 6E */  C_ERROR,
/* 6F */  C_ERROR,
/* 70 */  C_ERROR,
/* 71 */  C_ERROR,
/* 72 */  C_ERROR,
/* 73 */  C_ERROR,
/* 74 */  C_ERROR,
/* 75 */  C_ERROR,
/* 76 */  C_ERROR,
/* 77 */  C_ERROR,
/* 78 */  C_ERROR,
/* 79 */  C_ERROR,
/* 7A */  C_ERROR,
/* 7B */  C_ERROR,
/* 7C */  C_ERROR,
/* 7D */  C_ERROR,
/* 7E */  C_ERROR,
/* 7F */  C_ERROR,
/* 80 */  C_DATA66+C_REL,
/* 81 */  C_DATA66+C_REL,
/* 82 */  C_DATA66+C_REL,
/* 83 */  C_DATA66+C_REL,
/* 84 */  C_DATA66+C_REL,
/* 85 */  C_DATA66+C_REL,
/* 86 */  C_DATA66+C_REL,
/* 87 */  C_DATA66+C_REL,
/* 88 */  C_DATA66+C_REL,
/* 89 */  C_DATA66+C_REL,
/* 8A */  C_DATA66+C_REL,
/* 8B */  C_DATA66+C_REL,
/* 8C */  C_DATA66+C_REL,
/* 8D */  C_DATA66+C_REL,
/* 8E */  C_DATA66+C_REL,
/* 8F */  C_DATA66+C_REL,
/* 90 */  C_MODRM,
/* 91 */  C_MODRM,
/* 92 */  C_MODRM,
/* 93 */  C_MODRM,
/* 94 */  C_MODRM,
/* 95 */  C_MODRM,
/* 96 */  C_MODRM,
/* 97 */  C_MODRM,
/* 98 */  C_MODRM,
/* 99 */  C_MODRM,
/* 9A */  C_MODRM,
/* 9B */  C_MODRM,
/* 9C */  C_MODRM,
/* 9D */  C_MODRM,
/* 9E */  C_MODRM,
/* 9F */  C_MODRM,
/* A0 */  0,
/* A1 */  0,
/* A2 */  0,
/* A3 */  C_MODRM,
/* A4 */  C_MODRM+C_DATA1,
/* A5 */  C_MODRM,
/* A6 */  C_ERROR,
/* A7 */  C_ERROR,
/* A8 */  0,
/* A9 */  0,
/* AA */  0,
/* AB */  C_MODRM,
/* AC */  C_MODRM+C_DATA1,
/* AD */  C_MODRM,
/* AE */  C_ERROR,
/* AF */  C_MODRM,
/* B0 */  C_MODRM,
/* B1 */  C_MODRM,
/* B2 */  C_MODRM,
/* B3 */  C_MODRM,
/* B4 */  C_MODRM,
/* B5 */  C_MODRM,
/* B6 */  C_MODRM,
/* B7 */  C_MODRM,
/* B8 */  C_ERROR,
/* B9 */  C_ERROR,
/* BA */  C_MODRM+C_DATA1,
/* BB */  C_MODRM,
/* BC */  C_MODRM,
/* BD */  C_MODRM,
/* BE */  C_MODRM,
/* BF */  C_MODRM,
/* C0 */  C_MODRM,
/* C1 */  C_MODRM,
/* C2 */  C_ERROR,
/* C3 */  C_ERROR,
/* C4 */  C_ERROR,
/* C5 */  C_ERROR,
/* C6 */  C_ERROR,
/* C7 */  C_ERROR,
/* C8 */  0,
/* C9 */  0,
/* CA */  0,
/* CB */  0,
/* CC */  0,
/* CD */  C_DATA1,
/* CE */  0,
/* CF */  0,
/* D0 */  C_ERROR,
/* D1 */  C_ERROR,
/* D2 */  C_ERROR,
/* D3 */  C_ERROR,
/* D4 */  C_ERROR,
/* D5 */  C_ERROR,
/* D6 */  C_ERROR,
/* D7 */  C_ERROR,
/* D8 */  C_ERROR,
/* D9 */  C_ERROR,
/* DA */  C_ERROR,
/* DB */  C_ERROR,
/* DC */  C_ERROR,
/* DD */  C_ERROR,
/* DE */  C_ERROR,
/* DF */  C_ERROR,
/* E0 */  C_ERROR,
/* E1 */  C_ERROR,
/* E2 */  C_ERROR,
/* E3 */  C_ERROR,
/* E4 */  C_ERROR,
/* E5 */  C_ERROR,
/* E6 */  C_ERROR,
/* E7 */  C_ERROR,
/* E8 */  C_ERROR,
/* E9 */  C_ERROR,
/* EA */  C_ERROR,
/* EB */  C_ERROR,
/* EC */  C_ERROR,
/* ED */  C_ERROR,
/* EE */  C_ERROR,
/* EF */  C_ERROR,
/* F0 */  C_ERROR,
/* F1 */  C_ERROR,
/* F2 */  C_ERROR,
/* F3 */  C_ERROR,
/* F4 */  C_ERROR,
/* F5 */  C_ERROR,
/* F6 */  C_ERROR,
/* F7 */  C_ERROR,
/* F8 */  C_ERROR,
/* F9 */  C_ERROR,
/* FA */  C_ERROR,
/* FB */  C_ERROR,
/* FC */  C_ERROR,
/* FD */  C_ERROR,
/* FE */  C_ERROR,
/* FF */  C_ERROR
}; // ade32_table[]


int disasm(BYTE* opcode0, disasm_struct* diza)
{
	BYTE* opcode = opcode0;

	memset(diza, 0x00, sizeof(disasm_struct));
	diza->disasm_defdata = 4;
	diza->disasm_defaddr = 4;

	if(*(WORD*)opcode == 0x0000)
		return 0;
	if(*(WORD*)opcode == 0xFFFF)
		return 0;

	DWORD flag = 0;

	repeat_prefix:

	BYTE c = *opcode++;
	DWORD t = ade32_table[ c ];

	if(t & C_ANYPREFIX)
	{
		if(flag & t)
			return 0;

		flag |= t;

		if(t & C_67)
			diza->disasm_defaddr ^= 2^4;
		else if(t & C_66)
			diza->disasm_defdata ^= 2^4;
		else if(t & C_SEG)
			diza->disasm_seg = c;
		else if(t & C_REP)
			diza->disasm_rep = c;
		// LOCK

		goto repeat_prefix;
	} // C_ANYPREFIX

	flag |= t;
	diza->disasm_opcode = c;

	if(c == 0x0F)
	{
		c = *opcode++;
		diza->disasm_opcode2 = c;
		flag |= ade32_table[256+c]; // 2nd flagtable half
		
		if(flag == C_ERROR)
			return 0;
	}
	else if(c == 0xF7)
	{
		if(((*opcode) & 0x38) == 0)
			flag |= C_DATA66;
	}
	else if(c == 0xF6)
	{
		if(((*opcode) & 0x38) == 0)
			flag |= C_DATA1;
	}
	else if(c == 0xCD)
	{
		if(*opcode == 0x20)
			flag |= C_DATA4;
	}

	if(flag & C_MODRM)
	{
		c = *opcode++;
		diza->disasm_modrm = c;

		if(((c & 0x38) == 0x20) && (diza->disasm_opcode == 0xFF))
			flag |= C_STOP;

		BYTE mod = c & 0xC0;
		BYTE rm  = c & 0x07;

		if(mod != 0xC0)
		{
			if(diza->disasm_defaddr == 4)
			{
				if(rm == 4)
				{
					flag |= C_SIB;
					c = *opcode++;
					diza->disasm_sib = c;
					rm = c & 0x07;
				}

				if(mod == 0x40)
					flag |= C_ADDR1;
				else if(mod == 0x80)
					flag |= C_ADDR4;
				else if (rm == 5)
					flag |= C_ADDR4;
			}
			else
			{ // MODRM 16-bit
				if(mod == 0x40)
					flag |= C_ADDR1;
				else if(mod == 0x80)
					flag |= C_ADDR2;
				else if(rm == 6)
					flag |= C_ADDR2;
			}
		}
	} // C_MODRM

	diza->disasm_flag = flag;

	DWORD a =  flag & (C_ADDR1 | C_ADDR2 | C_ADDR4);
	DWORD d = (flag & (C_DATA1 | C_DATA2 | C_DATA4)) >> 8;

	if(flag & C_ADDR67)
		a += diza->disasm_defaddr;
	if(flag & C_DATA66)
		d += diza->disasm_defdata;

	diza->disasm_addrsize = a;
	diza->disasm_datasize = d;

	DWORD i;
	for(i = 0; i < a; i++)
		diza->disasm_addr_b[i] = *opcode++;

	for(i = 0; i < d; i++)
		diza->disasm_data_b[i] = *opcode++;

	diza->disasm_len = opcode - opcode0;

	return diza->disasm_len;
} // disasm()

int oplen(BYTE *opcode)
{
	disasm_struct diza;
	memset(&diza,0,sizeof(diza));
	
	disasm((BYTE*)opcode,&diza);

	if((diza.disasm_flag == C_ERROR) || ((diza.disasm_flag&C_STOP) == C_STOP) || ((diza.disasm_flag&C_REL)==C_REL) || ((diza.disasm_flag&C_BAD)==C_BAD))
		return -1;

	return diza.disasm_len;
}
    StdAfx.cpp
    Code:
    #include "StdAfx.h"
    d3dfont.cpp
    Code:
     #include <stdio.h>
#include <tchar.h>
#include <d3dx9.h>
#include "d3dfont.h"

//-----------------------------------------------------------------------------
// Custom vertex types for rendering text
//-----------------------------------------------------------------------------
#define MAX_NUM_VERTICES 50*6

struct FONT2DVERTEX { D3DXVECTOR4 p;   DWORD color;     FLOAT tu, tv; };
struct FONT3DVERTEX { D3DXVECTOR3 p;   D3DXVECTOR3 n;   FLOAT tu, tv; };

#define D3DFVF_FONT2DVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1)
#define D3DFVF_FONT3DVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)

inline FONT2DVERTEX InitFont2DVertex( const D3DXVECTOR4& p, D3DCOLOR color,
                                      FLOAT tu, FLOAT tv )
{
    FONT2DVERTEX v;   v.p = p;   v.color = color;   v.tu = tu;   v.tv = tv;
    return v;
}

inline FONT3DVERTEX InitFont3DVertex( const D3DXVECTOR3& p, const D3DXVECTOR3& n,
                                      FLOAT tu, FLOAT tv )
{
    FONT3DVERTEX v;   v.p = p;   v.n = n;   v.tu = tu;   v.tv = tv;
    return v;
}
//-----------------------------------------------------------------------------
// Name: CD3DFont()
// Desc: Font class constructor
//-----------------------------------------------------------------------------
CD3DFont::CD3DFont( const TCHAR* strFontName, DWORD dwHeight, DWORD dwFlags )
{
    _***ncpy( m_strFontName, strFontName, sizeof(m_strFontName) / sizeof(TCHAR) );
    m_strFontName[sizeof(m_strFontName) / sizeof(TCHAR) - 1] = _T('\0');
    m_dwFontHeight         = dwHeight;
    m_dwFontFlags          = dwFlags;
    m_dwSpacing            = 0;

    m_pd3dDevice           = NULL;
    m_pTexture             = NULL;
    m_pVB                  = NULL;

    m_pStateBlockSaved     = NULL;
    m_pStateBlockDrawText  = NULL;
}
//-----------------------------------------------------------------------------
// Name: ~CD3DFont()
// Desc: Font class destructor
//-----------------------------------------------------------------------------
CD3DFont::~CD3DFont()
{
    InvalidateDeviceObjects();
    DeleteDeviceObjects();
}
//-----------------------------------------------------------------------------
// Name: InitDeviceObjects()
// Desc: Initializes device-dependent objects, including the vertex buffer used
//       for rendering text and the texture map which stores the font image.
//-----------------------------------------------------------------------------
HRESULT CD3DFont::InitDeviceObjects( LPDIRECT3DDEVICE9 pd3dDevice )
{
    HRESULT hr;

    // Keep a local copy of the device
    m_pd3dDevice = pd3dDevice;

    // Establish the font and texture size
    m_fTextScale  = 1.0f; // Draw fonts into texture without scaling

    // Large fonts need larger textures
    if( m_dwFontHeight > 60 )
        m_dwTexWidth = m_dwTexHeight = 2048;
    else if( m_dwFontHeight > 30 )
        m_dwTexWidth = m_dwTexHeight = 1024;
    else if( m_dwFontHeight > 15 )
        m_dwTexWidth = m_dwTexHeight = 512;
    else
        m_dwTexWidth  = m_dwTexHeight = 256;

    // If requested texture is too big, use a smaller texture and smaller font,
    // and scale up when rendering.
    D3DCAPS9 d3dCaps;
    m_pd3dDevice->GetDeviceCaps( &d3dCaps );

    if( m_dwTexWidth > d3dCaps.MaxTextureWidth )
    {
        m_fTextScale = (FLOAT)d3dCaps.MaxTextureWidth / (FLOAT)m_dwTexWidth;
        m_dwTexWidth = m_dwTexHeight = d3dCaps.MaxTextureWidth;
    }

    // Create a new texture for the font
    hr = m_pd3dDevice->CreateTexture( m_dwTexWidth, m_dwTexHeight, 1,
                                      0, D3DFMT_A4R4G4B4,
                                      D3DPOOL_MANAGED, &m_pTexture, NULL );
    if( FAILED(hr) )
        return hr;

    // Prepare to create a bitmap
    DWORD*      pBitmapBits;
    BITMAPINFO bmi;
    ZeroMemory( &bmi.bmiHeader,  sizeof(BITMAPINFOHEADER) );
    bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);
    bmi.bmiHeader.biWidth       =  (int)m_dwTexWidth;
    bmi.bmiHeader.biHeight      = -(int)m_dwTexHeight;
    bmi.bmiHeader.biPlanes      = 1;
    bmi.bmiHeader.biCompression = BI_RGB;
    bmi.bmiHeader.biBitCount    = 32;

    // Create a DC and a bitmap for the font
    HDC     hDC       = CreateCompatibleDC( NULL );
    HBITMAP hbmBitmap = CreateDIBSection( hDC, &bmi, DIB_RGB_COLORS,
                                          (void**)&pBitmapBits, NULL, 0 );
    SetMapMode( hDC, MM_TEXT );

    // Create a font.  By specifying ANTIALIASED_QUALITY, we might get an
    // antialiased font, but this is not guaranteed.
    INT nHeight    = -MulDiv( m_dwFontHeight, 
        (INT)(GetDeviceCaps(hDC, LOGPIXELSY) * m_fTextScale), 72 );
    DWORD dwBold   = (m_dwFontFlags&D3DFONT_BOLD)   ? FW_BOLD : FW_NORMAL;
    DWORD dwItalic = (m_dwFontFlags&D3DFONT_ITALIC) ? TRUE    : FALSE;
    HFONT hFont    = CreateFont( nHeight, 0, 0, 0, dwBold, dwItalic,
                          FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
                          CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
                          VARIABLE_PITCH, m_strFontName );
    if( NULL==hFont )
        return E_FAIL;

    SelectObject( hDC, hbmBitmap );
    SelectObject( hDC, hFont );

    // Set text properties
    SetTextColor( hDC, RGB(255,255,255) );
    SetBkColor(   hDC, 0x00000000 );
    SetTextAlign( hDC, TA_TOP );

    // Loop through all printable character and output them to the bitmap..
    // Meanwhile, keep track of the corresponding tex coords for each character.
    DWORD x = 0;
    DWORD y = 0;
    TCHAR str[2] = _T("x");
    SIZE size;

    // Calculate the spacing between characters based on line height
    GetTextExtentPoint32( hDC, TEXT(" "), 1, &size );
    x = m_dwSpacing = (DWORD) ceil(size.cy * 0.3f);

    for( TCHAR c=32; c<127; c++ )
    {
        str[0] = c;
        GetTextExtentPoint32( hDC, str, 1, &size );

        if( (DWORD)(x + size.cx + m_dwSpacing) > m_dwTexWidth )
        {
            x  = m_dwSpacing;
            y += size.cy+1;
        }

        ExtTextOut( hDC, x+0, y+0, ETO_OPAQUE, NULL, str, 1, NULL );

        m_fTexCoords[c-32][0] = ((FLOAT)(x + 0       - m_dwSpacing))/m_dwTexWidth;
        m_fTexCoords[c-32][1] = ((FLOAT)(y + 0       + 0          ))/m_dwTexHeight;
        m_fTexCoords[c-32][2] = ((FLOAT)(x + size.cx + m_dwSpacing))/m_dwTexWidth;
        m_fTexCoords[c-32][3] = ((FLOAT)(y + size.cy + 0          ))/m_dwTexHeight;

        x += size.cx + (2 * m_dwSpacing);
    }

    // Lock the surface and write the alpha values for the set pixels
    D3DLOCKED_RECT d3dlr;
    m_pTexture->LockRect( 0, &d3dlr, 0, 0 );
    BYTE* pDstRow = (BYTE*)d3dlr.pBits;
    WORD* pDst16;
    BYTE bAlpha; // 4-bit measure of pixel intensity

    for( y=0; y < m_dwTexHeight; y++ )
    {
        pDst16 = (WORD*)pDstRow;
        for( x=0; x < m_dwTexWidth; x++ )
        {
            bAlpha = (BYTE)((pBitmapBits[m_dwTexWidth*y + x] & 0xff) >> 4);
            if (bAlpha > 0)
            {
                *pDst16++ = (WORD) ((bAlpha << 12) | 0x0fff);
            }
            else
            {
                *pDst16++ = 0x0000;
            }
        }
        pDstRow += d3dlr.Pitch;
    }

    // Done updating texture, so clean up used objects
    m_pTexture->UnlockRect(0);
    DeleteObject( hbmBitmap );
    DeleteDC( hDC );
    DeleteObject( hFont );

    return S_OK;
}
//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DFont::RestoreDeviceObjects()
{
    HRESULT hr;

    // Create vertex buffer for the letters
    int vertexSize = max( sizeof(FONT2DVERTEX), sizeof(FONT3DVERTEX ) );
    if( FAILED( hr = m_pd3dDevice->CreateVertexBuffer( MAX_NUM_VERTICES * vertexSize,
                                                       D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0,
                                                       D3DPOOL_DEFAULT, &m_pVB, NULL ) ) )
    {
        return hr;
    }

    // Create the state blocks for rendering text
    for( UINT which=0; which<2; which++ )
    {
        m_pd3dDevice->BeginStateBlock();
        m_pd3dDevice->SetTexture( 0, m_pTexture );

        if ( D3DFONT_ZENABLE & m_dwFontFlags )
            m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
        else
            m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );

        m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
        m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,   D3DBLEND_SRCALPHA );
        m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND,  D3DBLEND_INVSRCALPHA );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE,  TRUE );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHAREF,         0x08 );
        m_pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC,  D3DCMP_GREATEREQUAL );
        m_pd3dDevice->SetRenderState( D3DRS_FILLMODE,   D3DFILL_SOLID );
        m_pd3dDevice->SetRenderState( D3DRS_CULLMODE,   D3DCULL_CCW );
        m_pd3dDevice->SetRenderState( D3DRS_STENCILENABLE,    FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_CLIPPING,         TRUE );
        m_pd3dDevice->SetRenderState( D3DRS_CLIPPLANEENABLE,  FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_VERTEXBLEND,      D3DVBF_DISABLE );
        m_pd3dDevice->SetRenderState( D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_FOGENABLE,        FALSE );
        m_pd3dDevice->SetRenderState( D3DRS_COLORWRITEENABLE,
            D3DCOLORWRITEENABLE_RED  | D3DCOLORWRITEENABLE_GREEN |
            D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_MODULATE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
        m_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
        m_pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP,   D3DTOP_DISABLE );
        m_pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_POINT );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_POINT );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MIPFILTER, D3DTEXF_NONE );

        if( which==0 )
            m_pd3dDevice->EndStateBlock( &m_pStateBlockSaved );
        else
            m_pd3dDevice->EndStateBlock( &m_pStateBlockDrawText );
    }

    return S_OK;
}

#define SAFE_RELEASE(p)	if (p)  { free(p); p=NULL; }

//-----------------------------------------------------------------------------
// Name: InvalidateDeviceObjects()
// Desc: Destroys all device-dependent objects
//-----------------------------------------------------------------------------
HRESULT CD3DFont::InvalidateDeviceObjects()
{
    SAFE_RELEASE( m_pVB );
    SAFE_RELEASE( m_pStateBlockSaved );
    SAFE_RELEASE( m_pStateBlockDrawText );

    return S_OK;
}

//-----------------------------------------------------------------------------
// Name: DeleteDeviceObjects()
// Desc: Destroys all device-dependent objects
//-----------------------------------------------------------------------------
HRESULT CD3DFont::DeleteDeviceObjects()
{
    SAFE_RELEASE( m_pTexture );
    m_pd3dDevice = NULL;

    return S_OK;
}

//-----------------------------------------------------------------------------
// Name: GetTextExtent()
// Desc: Get the dimensions of a text string
//-----------------------------------------------------------------------------
HRESULT CD3DFont::GetTextExtent( const TCHAR* strText, SIZE* pSize )
{
    if( NULL==strText || NULL==pSize )
        return E_FAIL;

    FLOAT fRowWidth  = 0.0f;
    FLOAT fRowHeight = (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight;
    FLOAT fWidth     = 0.0f;
    FLOAT fHeight    = fRowHeight;

    while( *strText )
    {
        TCHAR c = *strText++;

        if( c == _T('\n') )
        {
            fRowWidth = 0.0f;
            fHeight  += fRowHeight;
        }

        if( (c-32) < 0 || (c-32) >= 128-32 )
            continue;

        FLOAT tx1 = m_fTexCoords[c-32][0];
        FLOAT tx2 = m_fTexCoords[c-32][2];

        fRowWidth += (tx2-tx1)*m_dwTexWidth - 2*m_dwSpacing;

        if( fRowWidth > fWidth )
            fWidth = fRowWidth;
    }

    pSize->cx = (int)fWidth;
    pSize->cy = (int)fHeight;

    return S_OK;
}


//-----------------------------------------------------------------------------
// Name: DrawText()
// Desc: Draws 2D text. Note that sx and sy are in pixels
//-----------------------------------------------------------------------------
HRESULT CD3DFont::DrawText( FLOAT sx, FLOAT sy, DWORD dwColor,
                            const TCHAR* strText, DWORD dwFlags )
{
    if( m_pd3dDevice == NULL )
        return E_FAIL;

    // Setup renderstate
    m_pStateBlockSaved->Capture();
    m_pStateBlockDrawText->Apply();
    m_pd3dDevice->SetFVF( D3DFVF_FONT2DVERTEX );
    m_pd3dDevice->SetPixelShader( NULL );
    m_pd3dDevice->SetStreamSource( 0, m_pVB, 0, sizeof(FONT2DVERTEX) );

    // Set filter states
    if( dwFlags & D3DFONT_FILTERED )
    {
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
        m_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
    }

    if( dwFlags & D3DFONT_RIGHT ) {
        SIZE sz;
        GetTextExtent( strText, &sz );
        sx -= (FLOAT)sz.cx;
    } else if( dwFlags & D3DFONT_CENTERED ) {
        SIZE sz;
        GetTextExtent( strText, &sz );
        sx -= (FLOAT)sz.cx/2.0f;
    }

    // Adjust for character spacing
    sx -= m_dwSpacing;
    FLOAT fStartX = sx;

    // Fill vertex buffer
    FONT2DVERTEX* pVertices = NULL;
    DWORD         dwNumTriangles = 0;
    m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD );

    while( *strText )
    {
        TCHAR c = *strText++;

        if( c == _T('\n') )
        {
            sx = fStartX;
            sy += (m_fTexCoords[0][3]-m_fTexCoords[0][1])*m_dwTexHeight;
        }

        if( (c-32) < 0 || (c-32) >= 128-32 )
            continue;

        FLOAT tx1 = m_fTexCoords[c-32][0];
        FLOAT ty1 = m_fTexCoords[c-32][1];
        FLOAT tx2 = m_fTexCoords[c-32][2];
        FLOAT ty2 = m_fTexCoords[c-32][3];

        FLOAT w = (tx2-tx1) *  m_dwTexWidth / m_fTextScale;
        FLOAT h = (ty2-ty1) * m_dwTexHeight / m_fTextScale;

        if( c != _T(' ') )
        {
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx1, ty2 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx1, ty1 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx2, ty2 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx2, ty1 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+w-0.5f,sy+h-0.5f,0.9f,1.0f), dwColor, tx2, ty2 );
            *pVertices++ = InitFont2DVertex( D3DXVECTOR4(sx+0-0.5f,sy+0-0.5f,0.9f,1.0f), dwColor, tx1, ty1 );
            dwNumTriangles += 2;

            if( dwNumTriangles*3 > (MAX_NUM_VERTICES-6) )
            {
                // Unlock, render, and relock the vertex buffer
                m_pVB->Unlock();
                m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );
                pVertices = NULL;
                m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD );
                dwNumTriangles = 0L;
            }
        }

        sx += w - (2 * m_dwSpacing);
    }

    // Unlock and render the vertex buffer
    m_pVB->Unlock();
    if( dwNumTriangles > 0 )
        m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwNumTriangles );

    // Restore the modified renderstates
    m_pStateBlockSaved->Apply();

    return S_OK;
}
    Part II


    main.cpp
    Code:
     //D3D Functions by N4n033 hacks and bypass and detours written in ASM by skinnlaw.

#include <d3d9.h>
#include <d3dx9.h>
#include <windows.h>
#include <stdio.h>
#include <fstream>
#include "main.h"
#include <time.h>
#include "byte.h"
#include "ShellApi.h"
#include "hsmethode.h"
#include "detour.h"
#include "d3dmenu.h"
#include "addies.h"
#include "int.h"

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")

UINT m_Stride;
UINT OffsetInBytes;
ID3DXFont* pFont;
LPDIRECT3DVERTEXBUFFER9 StreamData;
D3DMenu *SkinnLaw = NULL;
LPDIRECT3DDEVICE9 pDevice = 0; 
LPDIRECT3DTEXTURE9 aRed,aGreen,aBlue,aYellow,aPurple,aPink,aOrange,aGrey,aCyan,aBlack,aWhite,bRed,bGreen,bBlue,bPurple,bPink,bOrange,bYellow,bBlack,bWhite;



char* sFolder		[] = { " | + | "," | - | " };
char* sOnOff		[] = { "[ OFF ]","[ ON ]" };


//compare two string len
bool cmpstrlen(const char* str1,const char* str2)
{
	int len1,len2;

	len1 = strlen(str1);
	len2 = strlen(str2);

	if(len1 != len2)
		return false;
	return true;
}
void* WriteMEM( void* pvADRess, const void* pvBuffer, size_t stLen )
{
	MEMORY_BASIC_INFORMATION mbi;
	VirtualQuery( pvADRess, &mbi, sizeof( mbi ) );
	VirtualProtect( mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &mbi.Protect );
	void* pvRetn = memcpy( pvADRess, pvBuffer, stLen );
	VirtualProtect( mbi.BaseAddress, mbi.RegionSize, mbi.Protect, &mbi.Protect );
	FlushInstructionCache( GetCurrentProcess( ), pvADRess, stLen );
	return pvRetn;
}
void WriteAsm( void* pxADRess, BYTE *code, int size )
{
	unsigned long Protection;
	VirtualProtect((void*)pxADRess, size, PAGE_READWRITE, &Protection);
	memcpy((void*)pxADRess, (const void*)code, size);
	VirtualProtect((void*)pxADRess, size, Protection, 0);
}
void WriteMemory(PVOID ADRess, void* val, int bytes)
{ 
DWORD d, ds; 
VirtualProtect(ADRess, bytes, PAGE_EXECUTE_READWRITE, &d); 
memcpy(ADRess, val, bytes); 
VirtualProtect(ADRess,bytes,d,&ds);
}

void MakeLong(int adr , long x)
{
	unsigned long size;
	VirtualProtect((void*)adr, sizeof(x), PAGE_READWRITE, &size);
	memcpy((void*)adr, &x , sizeof(x));
	VirtualProtect((void*)adr, sizeof(x), size, 0);
}
//some macro
#define writebyte(addy,value) *(BYTE*)addy = value;
#define writefloat(addy,value) *(float*)addy = value;
#define writedouble(addy,value) *(double*)addy = value;
#define writelong(addy,value) *(long*)addy = value;
#define writeint(addy,value) *(int*)addy = value;
#define writedword(addy,value) *(DWORD*)addy = value;

/************************************/
/*		Create and draw menu		*/
/************************************/
// int //

// menu//
void BuildMenu(void)
{
 SkinnLaw->AddGroup("->Group1",&mi.item1,sFolder);
 if(mi.item1)
 {
	 SkinnLaw->AddText("Hooked by SkinnLaw");
 }
}



void DrawBox(int x, int y, int w, int h, D3DCOLOR Color,LPDIRECT3DDEVICE9 pDevice)
{
	struct Vertex																									   	{
		float x,y,z,ht;
		DWORD Color;
	};
	DWORD ColorBG;
	Vertex V[8];

	V[0].Color = V[1].Color = V[2].Color = V[3].Color = Color;
	V[0].z  = V[1].z   = V[2].z   = V[3].z   = 0.0f;
	V[0].ht = V[1].ht  = V[2].ht  = V[3].ht  = 0.0f;

	V[0].x = V[1].x = (float)x;
	V[0].y = V[2].y = (float)(y + h);
	V[1].y = V[3].y = (float)y;
	V[2].x = V[3].x = (float)(x + w);

	pDevice->SetTexture(0, NULL);
	pDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1); 
	pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,V,sizeof(Vertex));
} 

void DrawBox_s(LPDIRECT3DDEVICE9 pDevice , int x, int y, int w, int h, DWORD Color)
{
	D3DRECT rec;
	rec.x1 = x;
	rec.x2 = x + w;
	rec.y1 = y;
	rec.y2 = y + h;
	pDevice->Clear( 1, &rec, D3DCLEAR_TARGET, Color, 0, 0 );
}
void DrawRectangle(int x, int y, int w, int h, int s, DWORD Color, LPDIRECT3DDEVICE9 pDevice)
{
	DrawBox_s(pDevice, x, y, w, s, Color);
	DrawBox_s(pDevice, x, y, s, h, Color);
	DrawBox_s(pDevice, (x+w), y, s, h, Color);
	DrawBox_s(pDevice, x, (y+h), w+s, s, Color);
}

void DrawMenu(LPDIRECT3DDEVICE9 pDevice)
{
	if (!SkinnLaw) 
	{	
		SkinnLaw = new D3DMenu("<-SkinnLaw Public Hook->",130,300);
		SkinnLaw->visible=1;									        	
		SkinnLaw->col_title = Green;
	}else{
		if (!SkinnLaw->noitems)BuildMenu();
		if (SkinnLaw->visible==1)
          
		{
			

			if(SkinnLaw->visible==1){
				/*DrawSprite(pDevice);*/
		} 

			if(CH_BC==0)
			{
			DrawBox((float)13,(float)22,(float)160,(float)21,BlackTrans,pDevice);
			DrawBox((float)13,(float)43,(float)160,(float)SkinnLaw->noitems*SkinnLaw->height+12,BlackTrans,pDevice);// Grey 
			}
			if(CH_BC==1)
			{
				DrawBox((float)13,(float)22,(float)160,(float)21,GREEN,pDevice);
			DrawBox((float)13,(float)55,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GREY,pDevice);
			}
			if(CH_BC==2)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,GREEN,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GhostGREEN,pDevice);
			}
			if(CH_BC==3)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,GhostRED,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GhostRED,pDevice);
			}
			if(CH_BC==4)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,GhostPURPLE,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GhostPURPLE,pDevice);
			}
			{ "OFF","Red","Green","Blue","Yellow","Purple","Pink","Black","Cyan","White" ;};
			if(CH_BC==5)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,GhostYELLOW,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GhostYELLOW,pDevice);

			}
			if(CH_BC==6)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,GhostPINK,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GhostPINK,pDevice);
			}
			if(CH_BC==7)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,BlackTrans,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,BlackTrans,pDevice);
			}
			if(CH_BC==7)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,Red,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,Blue,pDevice);
			}
			if(CH_BC==8)
			{
				DrawBox((float)13,(float)22,(float)162,(float)21,GhostRED,pDevice);
			DrawBox((float)13,(float)43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,GhostRED,pDevice);
			}




			
			DrawRectangle((float)13,22,(float)162,(float)21,1,GhostBLUE,pDevice);
            DrawRectangle((float)13,43,(float)162,(float)SkinnLaw->noitems*SkinnLaw->height+12,1,GhostBLUE,pDevice);
		}
		SkinnLaw->Show(pFont,pDevice);
		SkinnLaw->Nav();
	}
}




void HackThread(void)
{
	//put hacks here
}




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 __stdcall myPresent ( LPDIRECT3DDEVICE9 pDevice, CONST RECT* pSourceRect,CONST RECT* pDestRect,HWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
{
	if(!Create)
	{
		D3DXCreateFont(pDevice, 14, 0, FW_HEAVY, 0, FALSE, DEFAULT_CHARSET, OUT_TT_ONLY_PRECIS, DEFAULT_QUALITY, /*DEFAULT_PITCH | */FF_DONTCARE, TEXT("Arial Rounded MT"), &pFont );
		if(pFont == NULL)D3DXCreateFont(pDevice, 14, 0, FW_HEAVY, 0, FALSE, DEFAULT_CHARSET, OUT_TT_ONLY_PRECIS, DEFAULT_QUALITY, /*DEFAULT_PITCH | */FF_DONTCARE, TEXT("Arial"), &pFont );

		Create = true;
	}
	
	if( pFont == NULL )
		pFont->OnLostDevice();
	else
		DrawMenu(pDevice);

		


		DrawMenu(pDevice);
        
        pFont->OnLostDevice();
		pFont->OnResetDevice();

	



HackThread();


	if(Color)
	{
		GenerateTexture(pDevice, &aRed,		Red);
		GenerateTexture(pDevice, &aYellow,	Yellow);
		GenerateTexture(pDevice, &aGreen,	Green);
		GenerateTexture(pDevice, &aBlue,	Blue);
		GenerateTexture(pDevice, &aPurple,	Purple);
		GenerateTexture(pDevice, &aPink,	Pink);
		GenerateTexture(pDevice, &aOrange,	Orange);
		GenerateTexture(pDevice, &aBlack,	Black);
		GenerateTexture(pDevice, &aWhite,	White);
		GenerateTexture(pDevice, &aGrey, 	Grey);
		GenerateTexture(pDevice, &aCyan, 	Cyan);
		Color = 0;
	}
	return pPresent(pDevice, pSourceRect, pDestRect, hDestWindowOverride, pDirtyRegion);
}


HRESULT WINAPI myEndScene (LPDIRECT3DDEVICE9 pDevice)
{
	

	return pEndScene(pDevice);
}

HRESULT WINAPI myDrawIndexedPrimitive(LPDIRECT3DDEVICE9 pDevice, D3DPRIMITIVETYPE Type, UINT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount)
{
	_asm pushad;


    LPDIRECT3DVERTEXBUFFER9 Stream_Data;
  UINT Offset = 0;
  UINT m_Stride = 0;

  if(pDevice->GetStreamSource(0, &Stream_Data, &Offset, &m_Stride) == D3D_OK)
  Stream_Data->Release();

	_asm popad;
	return pDrawIndexedPrimitive(pDevice, Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}



DWORD* FindDevice(DWORD Base) 
{
for(long i= 0,n = 0; i < 0x128000; i++ )
{
if(*(BYTE *)(Base+i+0x00)==0xC7)n++;
if(*(BYTE *)(Base+i+0x01)==0x06)n++;
if(*(BYTE *)(Base+i+0x06)==0x89)n++;
if(*(BYTE *)(Base+i+0x07)==0x86)n++;
if(*(BYTE *)(Base+i+0x0C)==0x89)n++;
if(*(BYTE *)(Base+i+0x0D)==0x86)n++;

if(n == 6) return (DWORD*)
(Base + i + 2);n = 0;
}
return(0);
}


#define RESET 16
#define PRESENT 17
#define DRAWINDEXEDPRIMITIVE  82
#define DETOUR_MAX_SRCH_OPLEN 64
//
#define RESET 16
#define PRESENT 17
#define DRAWINDEXEDPRIMITIVE  82
#define O_N_E 1
#define SLEEP123 Sleep
#define DIPUNHOOKTIME 98000

bool bCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
for(;*szMask;++szMask,++pData,++bMask)
if(*szMask=='x' && *pData!=*bMask )
return false;

return (*szMask) == NULL;
}
DWORD FindPattern(DWORD dwADRess,DWORD dwLen,BYTE *bMask,char * szMask)
{
for(DWORD i=0; i < dwLen; i++)
if( bCompare( (BYTE*)( dwADRess+i ),bMask,szMask) )
return (DWORD)(dwADRess+i);
return 0;
}

HRESULT WINAPI myReset (LPDIRECT3DDEVICE9 pDevice, D3DPRESENT_PARAMETERS* pPresentationParameters )
{
pFont->OnLostDevice();
HRESULT hRet = pReset(pDevice, pPresentationParameters);
pFont->OnResetDevice();
 return hRet;
}

DWORD GetADRessPtr(int index)
{
DWORD* VTableStart = 0;
DWORD dwDevicePointer = FindPattern((DWORD)GetModuleHandle("d3d9.dll"), 0x1280000, (PBYTE)"\xC7\x06\x00\x00\x00\x00\x89\x86\x00\x00\x00\x00\x89\x86", "xx????xx????xx");
memcpy(&VTableStart, (void*)(dwDevicePointer+2), 4);
return VTableStart[index];
}

int Hook()
{
	HINSTANCE hInstance;
	DWORD VTable[105];
	hInstance = 0;
	do {
		hInstance = GetModuleHandle("d3d9.dll");
		if (!hInstance)
			Sleep(50);
	}while(!hInstance);
if (D3Ddiscover((VOID *)&VTable[0],420)==0) return 0;
{
    pReset = (oReset)DetourCreateE9((DWORD)VTable[RESET], (DWORD)myReset,12);
    pPresent = (oPresent)DetourCreateE9((DWORD)VTable[PRESENT], (DWORD)myPresent,12);

while(8)
{
if(memcmp((void *)VTable[82],(void*)"\x8B\xFF",2) == 0 )
{
pDrawIndexedPrimitive = (oDrawIndexedPrimitive)DetourMePleaseImNice((DWORD)VTable[82], (DWORD)myDrawIndexedPrimitive,12);
}
Sleep(500);//wont paste ...
}
}
}


///************************************///
 //*		ATTACH DLL TO PROCESS	  *//
 /************************************/

BOOL WINAPI DllMain(HMODULE hDll, DWORD dwReason, LPVOID lpReserved)
{
	if (dwReason==DLL_PROCESS_ATTACH)
	{
		MessageBoxA(NULL, "Coded by SkinnLaw", "WwW.MPGH.NeT", MB_OK); 
		void Loop(void);
		HideModule(hDll);
		CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)Hook, NULL, NULL, NULL);
		BOOL APIENTRY DllMain(HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved);
	}
	return true;
}
    d3dmenu.cpp
    Code:
     #include "Color.h"
#include "d3dmenu.h"
#include "stdio.h"

/************************************/
/*			menu stuff 				*/
/************************************/

char file[255];

extern int mouse_enabled;
extern int drunk_enabled;
//extern void DrawBox( int x, int y, int w, int h, D3DCOLOR Color,LPDIRECT3DDEVICE9 pDevice);
extern void DrawRectangle(int x, int y, int w, int h, int s, DWORD Color, LPDIRECT3DDEVICE9 pDevice);

void D3DMenu::AddItem(char *txt, int *var, char **opt, int maxval, int typ)
{
  if (noitems>=(maxitems-3)) return;
  MENU[noitems]->typ=typ;
  MENU[noitems]->txt=txt;
  MENU[noitems]->opt=opt;
  MENU[noitems]->var=var;
  MENU[noitems]->maxval=maxval;
  noitems++;
  totheight=(noitems*height)+titleheight;
}

void D3DMenu::AddGroup(char *txt, int *var, char **opt, int maxval)
{
	AddItem(txt, var, opt, maxval, MENUFOLDER);
}

void D3DMenu::AddSubb(char *txt, int *var, char **opt, int maxval)
{
	AddItem(txt, var, opt, maxval, SUBFOLDER);
}

void D3DMenu::AddText(char *txt, char *opt)
{
	AddItem(txt,0,(char **)opt,0,MENUTEXT);
}


void DrawTextR(int x,int y,DWORD color,char *text, ID3DXFont*  pFont)
{
    RECT rect;
    SetRect( &rect, x, y, x, y );
    pFont->DrawTextA(NULL,text,-1,&rect, DT_RIGHT|DT_NOCLIP, color );
}

void DrawTextL(int x,int y,DWORD color,char *text, ID3DXFont*  pFont)
{
    RECT rect;
    SetRect( &rect, x, y, x, y );
    pFont->DrawTextA(NULL,text,-1,&rect, DT_LEFT|DT_NOCLIP, color );
}

void D3DMenu::DrawTextC(int x,int y,DWORD color,char *text, ID3DXFont*  pFont)
{
    RECT rect;
    SetRect( &rect, x, y, x, y );
    pFont->DrawTextA(NULL,text,-1,&rect, DT_CENTER|DT_NOCLIP, color );
}




void D3DMenu::Save(char* szSection, char* szKey, int iValue)
{
 char szValue[255];
 sprintf(szValue, "%d", iValue);
 WritePrivateProfileString(szSection,  szKey, szValue, file); 
}

int D3DMenu::Load(char* szSection, char* szKey, int iDefaultValue)
{
 int iResult = GetPrivateProfileInt(szSection,  szKey, iDefaultValue, file); 
 return iResult;
}


void D3DMenu::Show(ID3DXFont *pFont,LPDIRECT3DDEVICE9 pDevice)
{
	int i,val,cy;
	DWORD color;
	DWORD ColorQ;

	if (!visible)
		return;
	
	  max_x=x+143;	
	  max_y=y+totheight;
	  cy=y;

	if (title)
	{
		DrawTextC((float)(x+totwidth/3) - 31, (float)cy - 5, col_title, title, pFont);
		cy+=titleheight;
	}
	for(i=0; i<noitems; i++)
	{
		if(MENU[i]->typ==MENUTEXT)
		{
			DrawTextL(x, cy, White,MENU[i]->txt, pFont);
			if(MENU[i]->opt)
			{
				DrawTextR((float)(x+ofs), (float)cy, color,(char *)MENU[i]->opt, pFont);
			}
		}else{
			val=(MENU[i]->var)?(*MENU[i]->var):0;

			if (m_x>=x &&  m_x<max_x && m_y>=cy && m_y<(cy+height)) 
				color = Orange;
			else
				if (i==cur)
				color = col_current;
			else 
				if (MENU[i]->typ==MENUFOLDER)
				color=col_group;
			else 
				if (MENU[i]->typ==SUBFOLDER)
					color=(val)?col_on:col_off;
				else
					color=(val)?col_on:col_off;	

			if(val>0)
			{
				ColorQ = Green;
			}else{
				ColorQ = Red;
			}

			DrawTextL((float)x,(float)cy, color,MENU[i]->txt, pFont);
			if (MENU[i]->opt)
			{
				
				//DrawRectangle((float)17,(float)cy + 4.5,7,7,1,Blue,pDevice);
				DrawTextR((float)(x+143),(float)cy, color,(char *)MENU[i]->opt[val], pFont);
			}
		}
		cy+=height;
	}
}

int D3DMenu::FindItem(void)
{
   if (m_x<=x || m_x>=max_x || m_y<=y || m_y>=max_y) return -1;
   if ( (m_y-y) > titleheight) {
      int row = (m_y - y - titleheight) / height;
	  if (MENU[row]->typ==MENUTEXT || MENU[row]->var==0) return -1;
	  return row;
   } 
   return 999;
}

void D3DMenu::CheckTitleMove(int rm,int mx, int my)
{
	m_x=mx;
	m_y=my;
	if (rm && FindItem()==999)
	{
		moving=(!moving);
		dx=m_x - x;
		dy=m_y - y;
	} else if (moving && FindItem()!=999)
		moving=0;
}

void D3DMenu::Nav(void)
{
  if (GetAsyncKeyState(VK_INSERT)&1) visible=(!visible);

  if (!visible) 
	  return;

  if (GetAsyncKeyState(VK_CONTROL)) {
	if (GetAsyncKeyState(VK_UP)   &1); 
	if (GetAsyncKeyState(VK_DOWN) &1);
	if (GetAsyncKeyState(VK_LEFT) &1);
	if (GetAsyncKeyState(VK_RIGHT)&1);
  } else {
    if (GetAsyncKeyState(VK_UP)&1) {
		do {
			cur--;
			if (cur<0)  cur=noitems-1;
		} while (MENU[cur]->typ==MENUTEXT);	
	} else if (GetAsyncKeyState(VK_DOWN)&1) {
		do {
			cur++;
		    if (cur==noitems) cur=0;
		} while (MENU[cur]->typ==MENUTEXT);
	} else  {
		POINT mpos;
		int pos=cur;
		int dir=0;

		if (GetAsyncKeyState(VK_LEFT )&1  && MENU[cur]->var && *MENU[cur]->var > 0                     ) dir=-1;
		if (GetAsyncKeyState(VK_RIGHT)&1  && MENU[cur]->var && *MENU[cur]->var < (MENU[cur]->maxval-1) ) dir=1;

		if (dir==0 && (mouse_enabled==1)) {
			GetCursorPos(&mpos);
			ScreenToClient(GetForegroundWindow(),&mpos);
			m_x=mpos.x;
			m_y=mpos.y;
			m_lm	= GetAsyncKeyState(VK_LBUTTON )&1;
			m_rm	= GetAsyncKeyState(VK_RBUTTON )&1;

			if((m_lm || m_rm) && (pos=FindItem())!= -1)
			{
				if (pos!=999) {
					if (m_rm && *MENU[pos]->var>0) dir=-1;
					if (m_lm && *MENU[pos]->var<(MENU[pos]->maxval-1)) dir=1;
				} else if (m_rm) {
					moving=(!moving);
					dx=m_x - x;
					dy=m_y - y;
				}
			}
		}
		if (dir) {
			*MENU[pos]->var += dir;
			if (MENU[pos]->typ==MENUFOLDER) noitems=0;
			if (MENU[pos]->typ==SUBFOLDER) noitems=0;
		}
	}
  }
}

    Thanks this took my some hours..

    -AeroSkinn.
    Last edited by AeroSkinn; 06-17-2011 at 01:48 PM.

  2. The Following 2 Users Say Thank You to AeroSkinn For This Useful Post:

    Ahmed Madkour (03-05-2015),joshpe1 (06-19-2011)
  3. 06-17-2011 #2
    R3dLine
    R3dLine is offline
    Banned
    BANNED!
    R3dLine's Avatar
    Join Date
    Apr 2011
    Gender
    male
    Posts
    783
    Reputation
    212
    Thanks
    1,462
    Send a message via Birdie™ to R3dLine Palestinian Territory
    Code:
    If you leech please include credits:
@AeroSkinn(Coding & D3D)
N4n003(Coding Base)
    You sure about credits ? i think the correct credits is
    Karrka -> Base
    Detours ->Croner
    AeroSkin -> Just posting here no credits on Base [he got credits on tut cuz he made it] only maybe if he made some functions but all what i see is D3d font , And Menu Items no hacks functions .
    N4n003 -> coded base ? are u kidding me lol everybody know it karrka base .

    And about this detours dip it will crach it like 30 min better use Mid Hook.

    BTW you added much sleep on source more than need and what about dip sleep (500) WTF you want to Get game lag like hell ?
    Last edited by R3dLine; 06-17-2011 at 01:45 PM.
  4. 06-17-2011 #3
    AeroSkinn
    AeroSkinn is offline
    Threadstarter
    Banned
    BANNED!
    AeroSkinn's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    33
    Reputation
    10
    Thanks
    4
    My Mood
    Amused
    Send a message via Birdie™ to AeroSkinn United States
    Quote Originally Posted by R3dLine View Post
    Code:
    If you leech please include credits:
@AeroSkinn(Coding & D3D)
N4n003(Coding Base)
    You sure about credits ? i think the correct credits is
    Karrka -> Base
    Detours ->Croner
    AeroSkin -> Just posting here no credits on Base [he got credits on tut cuz he made it] only maybe if he made some functions but all what i see is D3d font , And Menu Items no hacks functions .
    N4n003 -> coded base ? are u kidding me lol everybody know it karrka base .

    And about this detours dip it will crach it like 30 min better use Mid Hook.

    BTW you added much sleep on source more than need and what about dip sleep (500) WTF you want to Get game lag like hell ?
    Edited ..

    Why (500) cause it had alot of hack features I all removed.
    Whats ur msn ?
  5. 06-18-2011 #4
    n4n033
    n4n033 is offline
    I Came, I Saw, I Conquered !
    Premium Member
    n4n033's Avatar
    Join Date
    Jan 2010
    Gender
    male
    Location
    Windows
    Posts
    1,090
    Reputation
    43
    Thanks
    2,425
    My Mood
    Cool
    Send a message via Birdie™ to n4n033 France M4G1K-N4n033 xN4n033
    R3dLine, its not KarraKa base but it was copy of Maxylopez93 Base -.-
    Last edited by n4n033; 06-18-2011 at 07:36 AM.


    The Only Bests :

    R3d_L!n3(Fares)
    Aeroman (Brent)
    TheCamels8 (Ori)
  6. 06-18-2011 #5
    _Headsh0t_
    _Headsh0t_ is offline
    Leecher
    MPGH Member
    _Headsh0t_'s Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    24
    Reputation
    10
    Thanks
    3
    My Mood
    Cheerful
    Send a message via Birdie™ to _Headsh0t_ Netherlands
    euh ik snap het niet zo goed wil je me helpen?

    wat heb je nodig.. en doe er download dingen bij van wat je nodig hebt.

    Friend List

    Flash

    My Self :P

    AeroSkinn

    AeroMan
  7. 06-18-2011 #6
    AeroSkinn
    AeroSkinn is offline
    Threadstarter
    Banned
    BANNED!
    AeroSkinn's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    33
    Reputation
    10
    Thanks
    4
    My Mood
    Amused
    Send a message via Birdie™ to AeroSkinn United States
    add my msn: a.mataich@live.nl
  8. 06-18-2011 #7
    _Headsh0t_
    _Headsh0t_ is offline
    Leecher
    MPGH Member
    _Headsh0t_'s Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    24
    Reputation
    10
    Thanks
    3
    My Mood
    Cheerful
    Send a message via Birdie™ to _Headsh0t_ Netherlands
    al gedaan

    ben je online op msn want je accepteert niet ik ben bloodynepz
    Last edited by _Headsh0t_; 06-18-2011 at 09:07 AM.

    Friend List

    Flash

    My Self :P

    AeroSkinn

    AeroMan
  9. 06-19-2011 #8
    n4n033
    n4n033 is offline
    I Came, I Saw, I Conquered !
    Premium Member
    n4n033's Avatar
    Join Date
    Jan 2010
    Gender
    male
    Location
    Windows
    Posts
    1,090
    Reputation
    43
    Thanks
    2,425
    My Mood
    Cool
    Send a message via Birdie™ to n4n033 France M4G1K-N4n033 xN4n033
    Ayoub delete KarraKa from credits, add Maxylopez93 & add me too ...


    The Only Bests :

    R3d_L!n3(Fares)
    Aeroman (Brent)
    TheCamels8 (Ori)
  10. 06-19-2011 #9
    AeroSkinn
    AeroSkinn is offline
    Threadstarter
    Banned
    BANNED!
    AeroSkinn's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    33
    Reputation
    10
    Thanks
    4
    My Mood
    Amused
    Send a message via Birdie™ to AeroSkinn United States
    New Credits:

    AeroSkinn(ayoub)
    Maxylopez93
    N4n033
  11. 06-19-2011 #10
    reborn556
    reborn556 is offline
    Dual-Keyboard Member
    MPGH Member
    reborn556's Avatar
    Join Date
    Jan 2011
    Gender
    male
    Location
    At your house
    Posts
    432
    Reputation
    11
    Thanks
    16
    My Mood
    Amazed
    Send a message via Birdie™ to reborn556 Philippines
    Is this tutorial the same with PH ?
    _______________________________________________
    There are no easy answer's but there are simple answers
    We must have the courage to do what is morally right
  12. 06-19-2011 #11
    R3dLine
    R3dLine is offline
    Banned
    BANNED!
    R3dLine's Avatar
    Join Date
    Apr 2011
    Gender
    male
    Posts
    783
    Reputation
    212
    Thanks
    1,462
    Send a message via Birdie™ to R3dLine Palestinian Territory
    Quote Originally Posted by n4n033 View Post
    Ayoub delete KarraKa from credits, add Maxylopez93 & add me too ...

    Ok and you got credits for ?
  13. 06-19-2011 #12
    AeroSkinn
    AeroSkinn is offline
    Threadstarter
    Banned
    BANNED!
    AeroSkinn's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    33
    Reputation
    10
    Thanks
    4
    My Mood
    Amused
    Send a message via Birdie™ to AeroSkinn United States
    Quote Originally Posted by reborn556 View Post
    Is this tutorial the same with PH ?
    PH has other detours
  14. 06-26-2011 #13
    Bijak
    Bijak is offline
    Leecher
    Bijak's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    4
    Reputation
    10
    Thanks
    0
    Send a message via Birdie™ to Bijak Poland
    Can someone know how to make D3D Menu in nomenu hack ??
  15. 06-26-2011 #14
    AeroMan
    AeroMan is offline
    Upcoming MPGHiean
    AeroMan's Avatar
    Join Date
    Dec 2008
    Gender
    male
    Location
    Hell
    Posts
    3,294
    Reputation
    189
    Thanks
    3,049
    My Mood
    Busy
    Send a message via Birdie™ to AeroMan Belgium
    Quote Originally Posted by Bijak View Post
    Can someone know how to make D3D Menu in nomenu hack ??
    its not a 'no menu' hack if you have d3d in it,that makes it D3D hack so a menu hack.

    To do that you need alot of directx & c++ skill
    Also you can download bases from other sites (google it)
  16. 06-26-2011 #15
    Bijak
    Bijak is offline
    Leecher
    Bijak's Avatar
    Join Date
    Jun 2011
    Gender
    male
    Posts
    4
    Reputation
    10
    Thanks
    0
    Send a message via Birdie™ to Bijak Poland
    A for Nomenu hack is something like D3D FAKE i remember before it was in visual basic but what about C++ ??
Page 1 of 2 12 LastLast
« Previous Thread | Next Thread »