[Source Code] CPlayer,cLTCharacterFx,CCharacterHitBox,ILTFontMan ager Acessing Class

Hi playerup, Today I'll show you how to acess some class with 1 ADDR

You can get information about class HERE

Code:
#include <stdint.h>
#define ADDR_CROSSFIRE_ENGINE_CLASS 0x11701E4

#include "SDK\engine\sdk\inc\ltbasedefs.h"
#include "SDK\engine\sdk\inc\iltmessage.h"

class LTVector
{
public:
float x, y, z;
};
class LTRotation
{
public:
float x, y, z, w;
};
class LTObject
{
public:
char _0x0000[4];
LTVector BoxMin; //0x0004
LTVector BoxMax; //0x0010
char _0x001C[128];
LTVector Scale; //0x009C
char _0x00A8[4];
unsigned int Type; //0x00AC
char _0x00B0[8];
LTVector Dimentions; //0x00B8
char _0x00C4[12];
LTVector ModelCullingPosition; //0x00D0
char _0x00DC[4];
LTVector Position; //0x00E0
LTRotation Rotation; //0x00EC
LTVector Velocity; //0x00FC
LTVector GlobalForceOverride; //0x0108
char _0x0114[8];
LTVector Acceleration; //0x011C
};//Size=0x0128
class CLTClient
{
public:
char pad_0000[1092]; //0x0000
}; //Size: 0x0444

class ILTCSBase
{
public:
CLTClient* pCLTClient; //0x0000
char _0x0001[123];
bool(WINAPIV *IntersectSegment)(IntersectQuery &iQuery, IntersectInfo *Info); //0x007C
char _0x0080[412];
void(WINAPIV *RunConsoleCommand)(CHAR *Command); //0x021C
char _0x0220[508];
LTRESULT SendToServer(ILTMessage_Read *pMsg, HOBJECT hSender, uint32 flags); //0x041C }; //Size: 0x0293

class CD3DDrawPrim
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTDrawPrim
{
public:
CD3DDrawPrim* pD3DDrawPrim; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTPhysicsClient
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTClientPhysics
{
public:
CLTPhysicsClient* pLTPhysicsClient; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CUIWidgetManager
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTWidgetManager
{
public:
CUIWidgetManager* pUIWidgetManager; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class D3DRenderStyles
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTRenderStyles
{
public:
D3DRenderStyles* pD3DRenderStyles; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CClientFileMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IClientFileMgr
{
public:
CClientFileMgr* pCClientFileMgr; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CClientShell
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CCamera
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CSideCamera
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CameraInstanse
{
public:
int m_Left, m_Top, m_Right, m_Bottom;
float m_xFov, m_yFov;
int m_bFullScreen;
LTVector m_LightAdd;
}; //Size: 0x0104

class pLTObjectCamera
{
public:
CameraInstanse* pCameraInstanse; //0x0000
D3DXVECTOR3 X; //0x0004
D3DXVECTOR3 Y; //0x0010
D3DXVECTOR3 Z; //0x001C
char pad_0028[60]; //0x0028
}; //Size: 0x0064

class CCameraBase
{
public:
CCamera* pCCamera; //0x0000
CSideCamera* pCSideCamera; //0x0004
char pad_0008[56]; //0x0008
pLTObjectCamera* pLTObject; //0x0040
char pad_0044[448]; //0x0044
}; //Size: 0x0204

class PlayerViewManager
{
public:
char pad_0000[4]; //0x0000
LTObject* pLTObject; //0x0004
char pad_0008[48]; //0x0008
__int32 CurrentWeaponId; //0x0038
char pad_003C[24]; //0x003C
float WeaponZoom; //0x0054
}; //Size: 0x0058

class CPlayerClntBase
{
public:
char pad_0000[76]; //0x0000
__int32 CameraObject; //0x004C
char pad_0050[636]; //0x0050
PlayerViewManager* pPlayerViewManager; //0x02CC
char pad_02D0[488]; //0x02D0
LTObject* pLTObjectNormal; //0x04B8
LTObject* pLTObjectZM; //0x04BC
char pad_04C0[4]; //0x04C0
float Yaw; //0x04C4
float Pitch; //0x04C8
float Roll; //0x04CC
char pad_04D0[32]; //0x04D0
float CameraYaw; //0x04F0
char pad_04F4[128]; //0x04F4
float WalkThroughtWalls1; //0x0574
float WalkThroughtWalls2; //0x0578
float WalkThroughtWalls3; //0x057C
__int32 iHealth; //0x0580
char pad_0584[88]; //0x0584
__int32 NoRecoil; //0x05DC
char pad_05E0[192]; //0x05E0
__int32 iCurrentWeaponID; //0x06A0
char pad_06A4[16]; //0x06A4
__int32 NoReload; //0x06B4
char pad_06B8[796]; //0x06B8
float Gravity; //0x09D4
char pad_09D8[620]; //0x09D8
}; //Size: 0x0C44

class CCharacterHitBox //do by yourself it's easy
{
public:
char pad_0000[324]; //0x0000
}; //Size: 0x0144

class cLTCharacterFX
{
public:
char pad_0000[508]; //0x0000
int8_t IsDead; //0x01FC
char pad_01FD[15]; //0x01FD
int8_t SpawnShield; //0x020C
char pad_020D[799]; //0x020D
CCharacterHitBox* pCCharacterHitBox; //0x052C
char pad_0530[124]; //0x0530
}; //Size: 0x05AC

class CPlayer
{
public:
char pad_0000[8]; //0x0000
LTObject* pLTObject; //0x0008
int8_t ClientID; //0x000C
int8_t Team; //0x000D
char Name[12]; //0x000E
char pad_001A[2]; //0x001A
cLTCharacterFX* CharacterFX; //0x001C
__int32 PlayerSlotTeam; //0x0020
char pad_0024[4]; //0x0024
float Has_C4; //0x0028
float State; //0x002C
__int32 Rank; //0x0030
char pad_0034[8]; //0x0034
int8_t Health; //0x003C
char pad_003D[1]; //0x003D
int8_t Kill; //0x003E
char pad_003F[1]; //0x003F
}; //Size: 0x0040

class IClientShellStub
{
public:
CClientShell* pCClientShell; //0x0000
char pad_0004[36]; //0x0004
CCameraBase* pCCameraBase; //0x0028
char pad_002C[60]; //0x002C
int8_t IsAlive; //0x0068
char pad_0069[7]; //0x0069
CPlayerClntBase* pCPlayerClntBase; //0x0070
int8_t InGame; //0x0074
char pad_0075[15]; //0x0075
void* ILTCSBase; //0x0084
char pad_0088[344]; //0x0088
CPlayer CPlayer; //0x01E0 // PlayerStart
char pad_0220[504]; //0x0220
}; //Size: 0x0418

class CSoundMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTSound
{
public:
CSoundMgr* pCSoundMgr; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTCursor
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTCursor
{
public:
CLTCursor* pCLTCursor; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTVideoMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTVideoMgr
{
public:
CLTVideoMgr* pCLTVideoMgr; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CSysTexInterFace
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTTexInterface
{
public:
CSysTexInterFace* pCSysTexInterFace; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CWorldClientBSP
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldClientBSP
{
public:
CWorldClientBSP* pCWorldClientBSP; //0x0000
char pad_0004[128]; //0x0004
}; //Size: 0x0084

class CWorldBlindObjectData
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldBlindObjectData
{
public:
CWorldBlindObjectData* pCWorldBlindObjectData; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CUIFontManager
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTFontManager
{
public:
CUIFontManager* pCUIFontManager; //0x0000
char pad_0004[128]; //0x0004
}; //Size: 0x0084

class pCLTRenderMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTRenderMgr
{
public:
pCLTRenderMgr* pCLTRenderMgr; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CWorldParticleBlockerData
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldParticleBlockerData
{
public:
CWorldParticleBlockerData* pCWorldParticleBlockerData; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class ILTModelClient
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTBenchMarkMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IWorldShareBSP
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTTransform
{
public:
char pad_0000[132]; //0x0000
}; //Size: 0x0084

class IClientDebugGraphMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ICommandLineArgsCommonImp
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class IServerFileMgr
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CNetHandler
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CRezPackItm
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CBaseHashItem
{
public:
char pad_0000[196]; //0x0000
}; //Size: 0x00C4

class CRezItm
{
public:
CRezPackItm* pCRezPackItm; //0x0000
char pad_0004[28]; //0x0004
CBaseHashItem* pBaseHashItem; //0x0020
char pad_0024[32]; //0x0024
}; //Size: 0x0044

class ICompress
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CLTModelServer
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class ILTModelServer
{
public:
CLTModelServer* pCLTModelServer; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CLTCommonClient
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CLTCommonShared
{
public:
CLTCommonClient* pCLTCommonClient; //0x0000
char pad_0004[64]; //0x0004
}; //Size: 0x0044

class CServerFunctions
{
public:
float ShowGameVars; //0x0000 It's a function Pointer
char pad_0004[8]; //0x0004
float ShowUsedFiles; //0x000C It's a function Pointer
char pad_0010[8]; //0x0010
float World; //0x0018 It's a function Pointer
char pad_001C[8]; //0x001C
float ObjectInfo; //0x0024 It's a function Pointer
char pad_0028[8]; //0x0028
float DisableWMPhysics; //0x0030 It's a function Pointer
char pad_0034[8]; //0x0034
float ExhaustMemory; //0x003C It's a function Pointer
char pad_0040[8]; //0x0040
float SpawnObject; //0x0048 It's a function Pointer
char pad_004C[8]; //0x004C
}; //Size: 0x0054

class IServerConsoleState
{
public:
char pad_0000[20]; //0x0000
CServerFunctions* pServerFunctions; //0x0014
char pad_0018[44]; //0x0018
}; //Size: 0x0044

class ILTServer
{
public:
char pad_0000[152]; //0x0000
virtual LTRESULT GetObjectPos(HLOCALOBJ hObj, LTVector *pPos) = 0; //0x0098
virtual LTRESULT GetObjectPos2(HLOCALOBJ hObj, LTVector *pPos) = 0; //0x009C
char pad_00A0[68]; //0x00A0
virtual LTRESULT GetWorldBox(LTVector &min, LTVector &max) = 0; //0x00E4
void* FindObjectIntersections; //0x00E8
char pad_00EC[8]; //0x00EC
virtual LTRESULT FindNamedObjects(const char *pName, BaseObjArray<HOBJECT> &objArray, uint32 *nTotalFound = NULL) = 0; //0x00F4
virtual LTRESULT SendToObject(ILTMessage_Read *pMsg, HOBJECT hSender, HOBJECT hSendTo, uint32 flags) = 0; //0x00F8
virtual LTRESULT SendToServer(ILTMessage_Read *pMsg, HOBJECT hSender, uint32 flags) = 0; //0x00FC
virtual LTRESULT SetObjectSFXMessage(HOBJECT hObject,ILTMessage_Read *pMsg) = 0; //0x0100
virtual LTRESULT SendToClient(ILTMessage_Read *pMsg,HCLIENT hSendTo, uint32 flags) = 0; //0x0104
virtual LTRESULT SendSFXMessage(ILTMessage_Read *pMsg, uint32 flags) = 0; //0x0108
virtual LTRESULT GetClientPing(HCLIENT hClient, float &ping) = 0; //0x010C
char pad_0110[8]; //0x0110
virtual LTRESULT GetClientAddr(HCLIENT hClient, uint8 pAddr[4], uint16 *pPort) = 0; //0x0118
char pad_011C[8]; //0x011C
virtual LTRESULT GetObjectName(HOBJECT hObject, char *pName,uint32 nameBufSize) = 0; //0x0124
void* GetNetFlags; //0x0128
void* SetNetFlags; //0x012C
char pad_0130[4]; //0x0130
void* GetClassDef; //0x0134
char pad_0138[4]; //0x0138
void* GetClassName; //0x013C
char pad_0140[4]; //0x0140
void* ThreadLoadFile; //0x0144
void* UnloadFile; //0x0148
void* GetHPolyObject; //0x014C
char pad_0150[1884]; //0x0150
}; //Size: 0x08AC
class ILTPhysics
{
public:
ILTServer* pLTServer; //0x0000
void* GetTcpIpAddress; //0x0004
char pad_0008[60]; //0x0008
}; //Size: 0x0044

class ILTServerPhysics
{
public:
char pad_0000[68]; //0x0000
}; //Size: 0x0044

class CrossFire_Engine_Class
{
public:
ILTCSBase* pLTCSBase; //0x0000
ILTDrawPrim* pLTDrawPrim; //0x0004
ILTClientPhysics* pLTClientPhysics; //0x0008
ILTWidgetManager* pLTWidgetManager; //0x000C
ILTRenderStyles* pLTRenderStyles; //0x0010
IClientFileMgr* pClientFileMgr; //0x0014
IClientShellStub* pClientShellStub; //0x0018
ILTSound* pLTSound; //0x001C
ILTCursor* pLTCursor; //0x0020
ILTVideoMgr* pLTVideoMgr; //0x0024
ILTTexInterface* pLTTexInterface; //0x0028
IWorldClientBSP* pWorldClientBSP; //0x002C
IWorldBlindObjectData* pWorldBlindObjectData; //0x0030
ILTFontManager* pLTFontManager; //0x0034
ILTRenderMgr* pLTRenderMgr; //0x0038
IWorldParticleBlockerData* pWorldParticleBlockerData; //0x003C
ILTModelClient* pLTModelClient; //0x0040
ILTBenchMarkMgr* pLTBenchMarkMgr; //0x0044
char pad_0048[4]; //0x0048
IWorldShareBSP* pWorldShareBSP; //0x004C
ILTTransform* pLTTransform; //0x0050
char pad_0054[12]; //0x0054
IClientDebugGraphMgr* pClientDebugGraphMgr; //0x0060
char pad_0064[12]; //0x0064
ICommandLineArgsCommonImp* pCommandLine; //0x0070
char pad_0074[8]; //0x0074
IServerFileMgr* pServerFileMgr; //0x007C
char pad_0080[8]; //0x0080
CNetHandler* pCNetHandler; //0x0088
char pad_008C[76]; //0x008C
CRezItm* pCRezItm; //0x00D8
char pad_00DC[200]; //0x00DC
ICompress* pCompress; //0x01A4
char pad_01A8[2000]; //0x01A8
ILTModelServer* pLTModelServer; //0x0978
char pad_097C[20]; //0x097C
CLTCommonShared* pCLTCommonShared; //0x0990
char pad_0994[16]; //0x0994
IServerConsoleState* pServerConsoleState; //0x09A4
char pad_09A8[20]; //0x09A8
ILTPhysics* pILTPhysics; //0x09BC
char pad_09C0[1080]; //0x09C0
ILTServerPhysics* pLTServerPhysics; //0x0DF8
char pad_0DFC[68]; //0x0DFC
}; //Size: 0x0E40
CrossFire_Engine_Class *pCrossFire_Engine_Class;
How get ADDR?
Code:
006B51E0 /. 55 PUSH EBP
006B51E1 |. 8BEC MOV EBP,ESP
006B51E3 |. 68 94010000 PUSH 194 ; /Arg3 = 00000194
006B51E8 |. 68 E4011701 PUSH CROSSFIR.011701E4 ; |Arg2 = 011701E4 // ADDR_ENGINE_CLASS
006B51ED |. 68 BC806F00 PUSH CROSSFIR.006F80BC ; |Arg1 = 006F80BC ASCII "ILTClient.Default"
006B51F2 |. B9 44401701 MOV ECX,CROSSFIR.01174044 ; |
006B51F7 |. E8 0482D5FF CALL CROSSFIR.0040D400 ; \CROSSFIR.0040D400
006B51FC |. 68 00306D00 PUSH CROSSFIR.006D3000
006B5201 |. E8 D9DCEFFF CALL CROSSFIR.005B2EDF
006B5206 |. 83C4 04 ADD ESP,4
006B5209 |. 5D POP EBP
006B520A \. C3 RETN
How to use?
Code:
void CALL_FUNCTIONS(int NoRecoil, int NoReload, int WTW, int FlyHack)
{
pCrossFire_Engine_Class = (CrossFire_Engine_Class *)(ADDR_CROSSFIRE_ENGINE_CLASS);
if (pCrossFire_Engine_Class->pClientShellStub->InGame == 1)
{
//InGame
if (NoRecoil)
{
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->NoRecoil = 0;
}
if (NoReload)
{
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->NoReload= 12;
}
if (WTW)
{
if (GetAsyncKeyState('T'))
{
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->WalkThroughtWalls1 = -56.0f;
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->WalkThroughtWalls2 = -140.0f;
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->WalkThroughtWalls3 = -56.0f;
}
}
if (FlyHack)
{
if (GetAsyncKeyState('F')) // FlyHack
{
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->Gravity = -2.5f;
}
else
{
pCrossFire_Engine_Class->pClientShellStub->pCPlayerClntBase->Gravity = 1.0f;
}
}
}
else
{
//Lobby
}
}
This class have more acess but i got lazy... try find bobo
Code:
class CrossFire_Engine_Class
{
public:
ILTCSBase* pLTCSBase; //0x0000
ILTDrawPrim* pLTDrawPrim; //0x0004
ILTClientPhysics* pLTClientPhysics; //0x0008
ILTWidgetManager* pLTWidgetManager; //0x000C
ILTRenderStyles* pLTRenderStyles; //0x0010
IClientFileMgr* pClientFileMgr; //0x0014
IClientShellStub* pClientShellStub; //0x0018
ILTSound* pLTSound; //0x001C
ILTCursor* pLTCursor; //0x0020
ILTVideoMgr* pLTVideoMgr; //0x0024
ILTTexInterface* pLTTexInterface; //0x0028
IWorldClientBSP* pWorldClientBSP; //0x002C
IWorldBlindObjectData* pWorldBlindObjectData; //0x0030
ILTFontManager* pLTFontManager; //0x0034
ILTRenderMgr* pLTRenderMgr; //0x0038
IWorldParticleBlockerData* pWorldParticleBlockerData; //0x003C
ILTModelClient* pLTModelClient; //0x0040
ILTBenchMarkMgr* pLTBenchMarkMgr; //0x0044
char pad_0048[4]; //0x0048
IWorldShareBSP* pWorldShareBSP; //0x004C
ILTTransform* pLTTransform; //0x0050
char pad_0054[12]; //0x0054
IClientDebugGraphMgr* pClientDebugGraphMgr; //0x0060
char pad_0064[12]; //0x0064
ICommandLineArgsCommonImp* pCommandLine; //0x0070
char pad_0074[8]; //0x0074
IServerFileMgr* pServerFileMgr; //0x007C
char pad_0080[8]; //0x0080
CNetHandler* pCNetHandler; //0x0088
char pad_008C[76]; //0x008C
CRezItm* pCRezItm; //0x00D8
char pad_00DC[200]; //0x00DC
ICompress* pCompress; //0x01A4
char pad_01A8[2000]; //0x01A8
ILTModelServer* pLTModelServer; //0x0978
char pad_097C[20]; //0x097C
CLTCommonShared* pCLTCommonShared; //0x0990
char pad_0994[16]; //0x0994
IServerConsoleState* pServerConsoleState; //0x09A4
char pad_09A8[20]; //0x09A8
ILTPhysics* pILTPhysics; //0x09BC
char pad_09C0[1080]; //0x09C0
ILTServerPhysics* pLTServerPhysics; //0x0DF8
char pad_0DFC[68]; //0x0DFC
}; //Size: 0x0E40
My old reverse ILTCSBase
Code:
class ILTCSBase
{
public:
void(*function01)(); //0x0000 Acess to ILTClient
void(*function02)(); //0x0004
void(*function03)(); //0x0008
void(*function04)(); //0x000C
void(*function05)(); //0x0010
void(*function06)(); //0x0014
void(*function07)(); //0x0018
void(*function08)(); //0x001C
void(*function09)(); //0x0020
void(*function10)(); //0x0024
void(*function11)(); //0x0028
void(*function12)(); //0x002C
void(*function13)(); //0x0030
void(*function14)(); //0x0034
void(*function15)(); //0x0038
void(*function16)(); //0x003C
void(*function17)(); //0x0040
void(*function18)(); //0x0044
void(*function19)(); //0x0048
void(*function20)(); //0x004C
void(*function21)(); //0x0050
void(*function22)(); //0x0054
void(*function23)(); //0x0058
void(*function24)(); //0x005C
void(*function25)(); //0x0060
void(*function26)(); //0x0064
void(*function27)(); //0x0068
void(*function28)(); //0x006C
bool(WINAPIV *IntersectSegment)(IntersectQuery &iQuery, IntersectInfo *Info); //0x0070
void(*function30)(); //0x0074
void(*function31)(); //0x0078
void(*function32)(); //0x007C
void(*function33)(); //0x0080
void(*function34)(); //0x0084
LTRESULT(*GetGameMode)(int *mode); //0x0088
LTRESULT(*StartGame)(/*StartGameRequest * int pRequest); //0x008C
LTRESULT(*GetLocalClientID)(uint32 *pID); //0x0090
void(*IsConnected)(); //0x0094
bool(*DisconnectRoom)(); //0x0098
void(*Shutdown)(); //0x009C
void(*Shutdown2)(); //0x00A0
LTRESULT(*GetPointShade)(LTVector *pPoint, LTVector *pColor); //0x00A4
LTRESULT(*FlipScreen)(uint32 flags); //0x00A8
LTRESULT(*Start3D)(); //0x00AC
LTRESULT(*RenderCamera)(HLOCALOBJ hCamera, float fFrameTime); //0x00B0
LTRESULT(*RenderObjects)(HLOCALOBJ hCamera, HLOCALOBJ *pObjects, int nObjects, float fFrameTime); //0x00B4
LTRESULT(*ClearScreen)(LTRect *pClearRect, uint32 flags, LTRGB* pClearColor); //0x00B8
LTRESULT(*MakeCubicEnvMap)(HLOCALOBJ hCamera, uint32 nSize, const char* pszFilePrefix); //0x00BC
LTRESULT(*StartOptimized2D)(); //0x00C0
LTRESULT(*EndOptimized2D)(); //0x00C4
LTRESULT(*SetOptimized2DBlend)(LTSurfaceBlend blend); //0x00C8
LTRESULT(*GetOptimized2DBlend)(LTSurfaceBlend &blend); //0x00CC
void(*function53)(); //0x00D0
LTRESULT(*End3D)(uint32 flags); //0x00D4
void(*function55)(); //0x00D8
LTRESULT(*GetOptimized2DColor)(HLTCOLOR &hColor); //0x00DC
RMode *(*GetRenderModes)(); //0x00E0
void(*RelinquishRenderModes)(RMode *pModes); //0x00E4
LTRESULT(*GetRenderMode)(RMode *pMode); //0x00E8
LTRESULT(*SetRenderMode)(RMode *pMode); //0x00EC
LTRESULT(*ShutdownRender)(uint32 flags); //0x00F0
void(*function62)(); //0x00F4
void(*function63)(); //0x00F8
void(*function64)(); //0x00FC
void(*function65)(); //0x0100
void(*function66)(); //0x0104
void(*function67)(); //0x0108
void(*function68)(); //0x010C
void(*function69)(); //0x0110
void(*function70)(); //0x0114
void(*function71)(); //0x0118
void(*function72)(); //0x011C
void(*function73)(); //0x0120
LTRESULT(*GetBorderSize)(HSURFACE hSurface, HLTCOLOR hColor, LTRect *pRect); //0x0124
LTRESULT(*OptimizeSurface)(HSURFACE hSurface, HLTCOLOR hTransparentColor); //0x0128
LTRESULT(*UnoptimizeSurface)(HSURFACE hSurface); //0x012C
void(*function77)(); //0x0130
void(*function78)(); //0x0134
void(*function79)(); //0x0138
void(*function80)(); //0x013C
void(*function81)(); //0x0140
void(*function82)(); //0x0144
void(*function83)(); //0x0148
void(*function84)(); //0x014C
void(*function85)(); //0x0150
void(*function86)(); //0x0154
void(*function87)(); //0x0158
void(*function88)(); //0x015C
void(*function89)(); //0x0160
void(*function90)(); //0x0164
void(*function91)(); //0x0168
void(*function92)(); //0x016C
void(*function93)(); //0x0170
void(*function94)(); //0x0174
void(*function95)(); //0x0178
void(*function96)(); //0x017C
void(*function97)(); //0x0180
void(*function98)(); //0x0184
void(*function99)(); //0x0188
void(*function100)(); //0x018C
void(*function101)(); //0x0190
void(*function102)(); //0x0194
void(*function103)(); //0x0198
void(*function104)(); //0x019C
void(*function105)(); //0x01A0
void(*function106)(); //0x01A4
void(*function107)(); //0x01A8
void(*function108)(); //0x01AC
void(*function109)(); //0x01B0
void(*function110)(); //0x01B4
void(*function111)(); //0x01B8
void(*function112)(); //0x01BC
void(*function113)(); //0x01C0
void(*function114)(); //0x01C4
void(*function115)(); //0x01C8
void(*function116)(); //0x01CC
void(*function117)(); //0x01D0
void(*function118)(); //0x01D4
void(*function119)(); //0x01D8
void(*function120)(); //0x01DC
void(*function121)(); //0x01E0
void(*function122)(); //0x01E4
void(*function123)(); //0x01E8
void(*function124)(); //0x01EC
void(*function125)(); //0x01F0
void(*function126)(); //0x01F4
void(*function127)(); //0x01F8
float(*GetGameTime)(); //0x01FC
float(*GetGameFrameTime)(); //0x0200
void(*function130)(); //0x0204
void(*function131)(); //0x0208
void(*function132)(); //0x020C
void(WINAPIV *RunConsoleCommand)(CHAR *Command); //0x0210
void(*function134)(); //0x0214
void(*function135)(); //0x0218
void(*function136)(); //0x021C
void(*function137)(); //0x0220
void(*function138)(); //0x0224
void(*function139)(); //0x0228
void(*function140)(); //0x022C
void(*function141)(); //0x0230
void(*function142)(); //0x0234
void(*function143)(); //0x0238
LTRESULT SendToServer(/*ILTMessage_Read int *pMsg, uint32 flags); //0x023C
LTRESULT GetServerIPAddress(uint8 pAddr[4], uint16 *pPort); //0x0240

};//Size=0x0244
Stuffs
Code:
struct RMode
{
//! Does this mode support hardware TnL?
bool m_bHWTnL;

//! This is what the DLLs use to identify a card.
char m_InternalName[128];

//! This is a 'friendly' string describing the card.
char m_Description[128];

//! The dimensions and bit depth of this mode
uint32 m_Width, m_Height, m_BitDepth;

//! The next mode in the list
RMode *m_pNext;
};
enum LTSurfaceBlend {
LTSURFACEBLEND_ALPHA, //! Alpha blend (lerp(src, dest, alpha))
LTSURFACEBLEND_SOLID, //! Solid (src)
LTSURFACEBLEND_ADD, //! Add (src + dest)
LTSURFACEBLEND_MULTIPLY, //! Multiply (src * dest)
LTSURFACEBLEND_MULTIPLY2, //! Multiply * 2 (src * dest * 2)
LTSURFACEBLEND_MASK, //! Mask ((1 - src) * dest)
LTSURFACEBLEND_MASKADD //! Mask & Add (src + (1 - src) * dest)
};

class LTRect {
public:

/*!
\param l x position of left side
\param t y position of top side
\param r x position of right side
\param b y position of bottom side

Used for: Misc.
*/
LTRect(int l = 0, int t = 0, int r = 0, int b = 0) : left(l), top(t), right(r), bottom(b) {}

/*!
\param inLeft x position of left side
\param inTop y position of top side
\param inRight x position of right side
\param inBottom y position of bottom side

Initialize the values.

Used for: 2D Rendering.
*/
void Init(int inLeft, int inTop, int inRight, int inBottom) {
left = inLeft;
top = inTop;
right = inRight;
bottom = inBottom;
}

int left, top, right, bottom;
};

struct LTRGB { uint8 b, g, r, a; };
Hey bro, how you do this?
I used REClass
Credits: ReClass and dreek1
GoodBye playerup : (
​