CODING BASICS

PHP CODE]DWORD dwEBX = NULL;

HRESULT WINAPI new_DrawIndexedPrimitive(LPDIRECT3DDEVICE9 pDevice, D3DPRIMITIVETYPE Type, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount)
{
_asm mov dwEBX, ebx;

// If you want to find this function (caller) again, do this:
// F7 40 04 00 00 00 10

BYTE* pReturnAddressBytes = (BYTE*) _ReturnAddress();

pReturnAddressBytes -= 0x2F;

if(
pReturnAddressBytes[0] == 0xC1 &&
pReturnAddressBytes[1] == 0xE8 &&
pReturnAddressBytes[2] == 0x1F)
{
_asm push eax;
_asm mov eax, dwEBX;
_asm mov eax, [eax];
_asm mov dwEBX, eax;
_asm pop eax;

char* modelName = (char*)(dwEBX + 0x14);

if(GetAsyncKeyState(VK_F3) != 0)
{
gApp.AddToLogFileA("obj.log", "%s (0x%X)", (char*)(dwEBX + 0x14), ((DWORD)_ReturnAddress() - (DWORD)GetModuleHandle(NULL)));
}

if(gLiveMenu.esp_chams->Boolean())
{
if(
_strnicmp(modelName, "Hero_", 5) == 0 || // Player Models
_strnicmp(modelName, "Gear_", 5) == 0 || // Gear (backpacks, etc)
_strnicmp(modelName, "HGEAR_", 6) == 0 || // Headgear (masks, helmets, etc)
_strnicmp(modelName, "HEADHELMET", 10) == 0 || // Helmet
_strnicmp(modelName, "ARMOR_", 6) == 0 || // Armor
_strnicmp(modelName, "Head_", 5) == 0 || // Head stuff
_strnicmp(modelName, "Mask_", 5) == 0 || // Mask (again?)
_strnicmp(modelName, "UpperBody_", 10) == 0 || // Shirts and crap
_strnicmp(modelName, "LowerBody_", 10) == 0 // Pants and crap
)
{
// Player!
}
else if(_strnicmp(modelName, "Zombie_", 7) == 0) // Zombies (Zombie_ and zombie_)
{
//Zombie!
}
else if(
_strnicmp(modelName, "SHG_", 4) == 0 || // Shotguns (again??)
_strnicmp(modelName, "SMG_", 4) == 0 || // Submachine Guns
_strnicmp(modelName, "MG_", 3) == 0 || // Machine Guns
_strnicmp(modelName, "ASR_", 4) == 0 || // Assault Rifles
_strnicmp(modelName, "SNP_", 4) == 0 || // Sniper Rifles
_strnicmp(modelName, "EXP_", 4) == 0 || // Explosives
_strnicmp(modelName, "Consumables_", 12) == 0 || // Consumables
_strnicmp(modelName, "Item_", 5) == 0 || // Items (Item_ and item_)
_strnicmp(modelName, "MEL_", 4) == 0 || // Melee
_strnicmp(modelName, "HG_", 3) == 0 || // Hand Guns
_strnicmp(modelName, "SUP_", 4) == 0 || // Suppressors
_strnicmp(modelName, "Loot_", 5) == 0 || // Loot
_strnicmp(modelName, "ATTM_", 5) == 0 // Attachments
)
{
//Items!
}
}
}

return gOrig.DrawIndexedPrimitive(pDevice, Type, BaseVertexIndex, MinVertexIndex, NumVertices, startIndex, primCount);
}

#pragma once

class CInternalGameVar
{
public:
template<typename T> void Set(T v)
{
*(T*)((DWORD)this + 0x184) = v;
}

template<typename T> T Get()
{
return *(T*)((DWORD)this + 0x184);
}

template<typename T> T GetDefault()
{
return *(T*)((DWORD)this + 0x188);
}

template<typename T> T Min()
{
return *(T*)((DWORD)this + 0x18C);
}

template<typename T> T Max()
{
return *(T*)((DWORD)this + 0x190);
}

char* Name()
{
return (char*)((DWORD)this);
}

char* Desc()
{
return (char*)((DWORD)this + 0x84);
}
};

class CGameVar
{
public:
template<typename T> void Set(T v)
{
Internal()->Set<T>(v);
}

template<typename T> T Get()
{
return Internal()->Get<T>();
}

__forceinline CInternalGameVar* Internal()
{
return *(CInternalGameVar**)((DWORD)this + 0x94);
}

__forceinline CGameVar* Next()
{
return *(CGameVar**)((DWORD) this + 0x8C);
}
};

class CGameVarList
{
public:
CGameVar* firstVariable()
{
return (CGameVar*) *(DWORD*)((DWORD)this + 0x8008);
}

CGameVar* Get(char* name)
{
CGameVar* pVar = firstVariable();

while(pVar && pVar->Internal())
{
if(!strcmp(pVar->Internal()->Name(), name))
{
return pVar;
}

pVar = pVar->Next();
}

return NULL;
}

static CGameVarList* Singleton();
};

CGameVarList* CGameVarList::Singleton()
{
static DWORD dwGameVarList = NULL;

if(dwGameVarList == NULL)
{
dwGameVarList = gApp.FindPattern(GetModuleHandle(NULL),
(BYTE*)"\x56\x57\x8B\xF0\x68\x80\x00\x00\x00",
(CHAR*)"\x01\x01\x01\x01\x01\x01\x01\x01\x01");

if(dwGameVarList == NULL)
{
gApp.Assert("Unable to find [CGameVarList::Singleton]");
}

dwGameVarList = dwGameVarList - 4;
dwGameVarList = *(DWORD*) dwGameVarList;
}

return (CGameVarList*) *(DWORD*) dwGameVarList;
}

CGameVarList* pVarList = CGameVarList::Singleton();

if(pVarList)
{
CGameVar* pGrassView = (CGameVar*) pVarList->Get("r_grass_draw");

if(pGrassView)
{
pGrassView->Set<int>(0);
}
}

class 3dRenderer
{
public:
unsigned char __PAD0001[0x8];

HWND hwnd; // 0x0008 (Size: 0x0004)

unsigned char __PAD0002[0xC];

int windowW; // 0x0018 (Size: 0x0004)
int windowH; // 0x001C (Size: 0x0004)

unsigned char __PAD0003[0x14];

HWND hwnd2; // 0x0034 (Size: 0x0004)

unsigned char __PAD0004[0x8];

int refreshRate; // 0x0040 (Size: 0x0004)

unsigned char __PAD0005[0xC];

void * pd3ddev; // 0x0050 (Size: 0x0004)
};

3dRenderer * r3dRenderer = ( 3dRenderer *)( *( PDWORD )( dwModBase + 0xDCDEF4 ) );

#pragma once

class C3DRenderer
{
public:
unsigned char unk0[0x50]; //0000
IDirect3DDevice9* pd3ddev; //0050

static C3DRenderer* Singleton();
};

#include "stdafx.h"
#include "C3DRenderer.h"

DWORD dwRenderAddress = NULL;

C3DRenderer* C3DRenderer::Singleton()
{
if(dwRenderAddress == NULL)
{
//A1 ? ? ? ? 68 02 04 00 40 E8

dwRenderAddress = gApp.FindPattern(GetModuleHandle(NULL),
(BYTE*)"\xA1\x00\x00\x00\x00\x68\x02\x04\x00\x40\x E8",
(CHAR*)"\x01\x02\x02\x02\x02\x01\x01\x01\x01\x01\x 01");

if(dwRenderAddress == NULL)
{
return NULL;
}

dwRenderAddress = *(DWORD*)(dwRenderAddress + 1);
}

return (C3DRenderer*) *(DWORD*) dwRenderAddress;
}

#pragma once

class Render
{
public:

static void renderText(float posX, float posY, int color, char* text);
static void renderRect(int x, int y, int w, int h, D3DCOLOR Color);
};

#include "stdafx.h"
#include "Render.h"

DWORD dwTextRender = 0;
DWORD dwRenderTextCallAddress = 0;
DWORD dwRenderFontAddress = 0;

typedef int (__cdecl* renderText_t)(void*, float, float, int*, char*, ...);

void Render::renderText(float posX, float posY, int color, char* text)
{
C3DRenderer* pRenderer = C3DRenderer::Singleton();

if(pRenderer == NULL) return;
if(pRenderer->pd3ddev == NULL) return;

if(dwTextRender == NULL)
{
dwTextRender = gApp.FindPattern(GetModuleHandle(NULL),
(BYTE*)"\xC7\x44\x24\x30\x25\x2B\xF3\xFF",
(CHAR*)"\x01\x01\x01\x01\x01\x01\x01\x01");

if(dwTextRender == NULL)
{
return;
}

dwRenderFontAddress = *(DWORD*)(dwTextRender - 0x36);
dwRenderTextCallAddress = gApp.GetCallAddress(dwTextRender + 8);
}

DWORD** pFont = (DWORD**) dwRenderFontAddress;

if(!*pFont) return;

DWORD dwRenderState = 0;
pRenderer->pd3ddev->GetRenderState( D3DRS_ZFUNC, &dwRenderState );
pRenderer->pd3ddev->SetRenderState( D3DRS_ZFUNC, D3DCMP_ALWAYS );
((renderText_t) dwRenderTextCallAddress)(*pFont, posX, posY, &color, text);
pRenderer->pd3ddev->SetRenderState( D3DRS_ZFUNC, dwRenderState );
}

void Render::renderRect(int x, int y, int w, int h, D3DCOLOR Color)
{
C3DRenderer* pRenderer = C3DRenderer::Singleton();

if(pRenderer == NULL) return;
if(pRenderer->pd3ddev == NULL) return;

D3DRECT rect = { x, y, x + w, y + h };

pRenderer->pd3ddev->Clear( 1, &rect, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, Color, 0, 0 );
}

void SetModelColor(LPDIRECT3DDEVICE9 pDevice, float r, float g, float b, float a, float glowr, float glowg, float glowb, float glowa)
{
float lightValues[4] = {r, g, b, a};
float glowValues[4] = {glowr, glowg, glowb, glowa};

pDevice->SetPixelShaderConstantF(1, lightValues, 1);
pDevice->SetPixelShaderConstantF(3, glowValues, 1);
}

// Generated by Microsoft (R) HLSL Shader Compiler 9.29.952.3111
//
// Parameters:
//
// float4 DefSSAO;
// sampler2D DetailNormalMap;
// sampler2D DiffuseTex;
// sampler2D EnvPowerMap;
// sampler2D GlossMap;
// float4 Mat_Diffuse;
// float4 Mat_Glow;
// float4 Material_Params;
// sampler2D NormalTex;
// sampler2D SSSMap;
// sampler2D SelfIllumMap;
// sampler2D SpecPowMap;
//
//
// Registers:
//
// Name Reg Size
// --------------- ----- ----
// Material_Params c0 1
// Mat_Diffuse c1 1
// Mat_Glow c3 1
// DefSSAO c7 1
// DiffuseTex s0 1
// NormalTex s1 1
// GlossMap s2 1
// EnvPowerMap s3 1
// SelfIllumMap s4 1
// DetailNormalMap s5 1
// SSSMap s6 1
// SpecPowMap s7 1
//

ps_3_0
def c2, 2, -1, 5, 0.5
dcl_texcoord v0.xyz
dcl_texcoord1 v1.xyz
dcl_texcoord2 v2.xyz
dcl_texcoord3 v3.xyz
dcl vFace
dcl_2d s0
dcl_2d s1
dcl_2d s2
dcl_2d s3
dcl_2d s4
dcl_2d s5
dcl_2d s6
dcl_2d s7
texld r0, v0, s0
mul oC0.xyz, r0, c1
texld r0, v0, s3
mul oC3.w, r0.x, c0.y
texld r0, v0, s7
mul oC3.y, r0.x, c0.z
mul r0.xy, c3.z, v0
mul r0.xy, r0, c2.z
texld r0, r0, s5
mad r0.xy, r0, c2.x, c2.y
mul r0.xy, r0, c3.w
texld r1, v0, s1
mad r1.xyz, r1, c2.x, c2.y
mad r1.xy, r0, c2.x, r1
nrm r0.xyz, r1
mul r1.xyz, r0.y, v3
mad r0.xyw, r0.x, v2.xyzz, r1.xyzz
cmp r1.xyz, vFace, v1, -v1
mad r0.xyz, r0.z, r1, r0.xyww
nrm r1.xyz, r0
mad oC1.xyz, r1, c2.w, c2.w
texld r0, v0, s2
mul oC0.w, r0.x, c0.x
texld r0, v0, s4
mul oC1.w, r0.x, c3.x
mov oC2, v0.z
mov oC3.x, c7.x
texld r0, v0, s6
mov oC3.z, r0.y

// approximately 33 instruction slots used (8 texture, 25 arithmetic)