Source Code CryEngine

  
#pragma once
#include "CryTools.h"

//////////////////
/*
UPDATE CHEAT DATE: 20.05.2020
GAME: WARFACE EU
*/
//////////////////


// PlayerDummy or ObserverPlayer [+ GameFrameWork + Game]
/*
if ( !dword_1B4D79C )
{
dword_1B4D79C = (*(int (**)(void))(*(_DWORD *)dword_1B53138 + 56))(); [dword_1B4D79C] - GameFrameWork [dword_1B53138] - Game
v12 = (*(int (**)(void))(*(_DWORD *)dword_1B53138 + 56))(); [dword_1B53138] - Game
dword_1B4D7A0 = (*(int (__thiscall **)(int))(*(_DWORD *)v12 + 0x78))(v12);
dword_1B4D798 = (*(int (**)(void))(*(_DWORD *)dword_1B4D79C + 104))(); [dword_1B4D798] - IItemSystem
}
ray: 384 / 4 = 86
srwi: 136 / 4 = 34
*/

enum GameData : int32
{
	dwGlobalAdress = 0x1926580,
	dwBaseRender = 0x1B4A50C,
	dwBaseGameCVar = 0x1B53128, // g_victoryCondition
	dwBaseGameFrameWork = 0x1B4D79C, 
	dwBaseIItemSystem = 0x1B4D798, 
	dwBaseProjection = 0x1B45724, //74 14 56 81 C7 AC 00 00 00 B9 10 00 00 00 BE
	dwBaseMatrix = dwBaseProjection + 0x40, // BE 4C 55 B3 01
};

enum IRenderData : int32
{
	GetCameraI = 0x1044,
	GetWidthI = 0x7018,
	GetHeightI = 0x701C, //85 C0 74 08 8B 10 57 8B  C8 FF 52 18 80 BE 2C 70
};

enum IEntityData : int32
{
	GetEntityIdI = 0x4,
	GetEntityClassI = 0x28,
	GetFlagsI = 0x4,
	GetRawIdI = 0x14,
	GetWorldTMI = 0x30,
	GetNameI = 0xB8,
	GetClassNameI = 0x8,
	GetRotationI = 0x78
};

enum IActorData : int32
{
	GetEntityI = 0x8,
	GetActorIdI = 0x10,
	GetTeamIdI = 0x344, // (gameParams) 55 8B EC 81 EC 9C 01 ??  ?? 53 56 FF 75 08 8B D9 or 84 C0 74 09 6A 01 8B CE (Revive) if ( v17 ) (*(void(__thiscall **)(int, int, _DWORD, int))(*(_DWORD *)v17 + 292))(v17, v3, *(_DWORD *)(v3 + 0x348), a3);
	GetPlayerI = 0x964, // 55 8B EC 8B 89 ? ? ? ? 8B 45 08 F3 0F 7E 81
	SetScaleI = 0xC0,
	claymore_detector_radiusI = 0xB00,
	leanAngleI = 0xB2C,
	WeaponIdI = leanAngleI + 0x4,
	slideDistanceMultI = 0xC3C,
	GetClassIdI = 0x3A0 // 85 C0 74 0A 8B 10 8B C8  FF 52 20 C2 04 00 33 C0 mov eax, [ecx+3A4h] retn
};

enum IWeaponData : int32
{
	IWeaponSpecificI = 0x4,
	SetFiringPosI = 0x10,
	IWeaponExtraI = 0x24,
	IWeaponCryptI = 0x30,
	IWeaponAmmoI = 0x34,
	ShutterI = 0x8A,
	GetWeaponStanceI = 0x70,
	DamageI = 0x8
};

enum ICVarData : int32
{
	i_pelletsDispI = 0x118,
	g_victoryConditionI = 0x57C,
	g_ingame_afk_timeoutI = 0x6F8,
	g_gameroom_afk_timeoutI = 0x6F4,
	g_anti_cheat_memscan_thread_delayI = 0xA28,
	g_anti_cheat_memscan_logI = 0xA2C,
	g_anti_cheat_memscan_dump_patternsI = 0xA30
};

class IRender
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
	template<class cData> void TSetValue(int32 dwOffset, cData Value)
	{
		Write<cData>((dwOffset), Value);
	}
public:
	static IRender* Singleton()
	{
		return Read<IRender*>(GameData::dwBaseRender);
	}

	Vec3 GetCamera()
	{
		return GetValue<Vec3>(IRenderData::GetCameraI);
	}

	int32 GetWidth()
	{
		return GetValue<int32>(IRenderData::GetWidthI);
	}

	int32 GetHeight()
	{
		return GetValue<int32>(IRenderData::GetHeightI);
	}

	bool ProjectToScreen(int32*vp, f32 ptx, f32 pty, f32 ptz, f32* sx, f32* sy, f32* sz)
	{
		Vec3 vOut, vIn;
		vIn.x = ptx;
		vIn.y = pty;
		vIn.z = ptz;
		int32 v[4] = { vp[0], vp[1], vp[2], vp[3] };
		Matrix44 mIdent;
		mIdent.SetIdentity();
		Matrix44 View = TGetValue<Matrix44>(GameData::dwBaseProjection);
		Matrix44 Projection = TGetValue<Matrix44>(GameData::dwBaseMatrix);
		if (__mathVec3Project(&vOut, &vIn, v, &Projection, &View, &mIdent))
		{
			*sx = vOut.x* 100.0f / (f32)v[2];
			*sy = vOut.y* 100.0f / (f32)v[3];
			*sz = vOut.z;
			return true;
		}
		return false;
	}

	void DrawAABB(AABB aabb)
	{
		int32 v2 = (int32)this + 0xC * (GetValue<int32>(0xE08) + 0x93A);
		int32 v0 = TGetValue<int32>(v2);
		int32 v3 = TGetValue<int32>(v2 + 0x4);

		if (!v0 || !v3) return;

		if (v0 == v3)
		{
			TSetValue(v0, aabb);
			TSetValue(v2 + 0x4, v0 + 0x18);
		}
	}
};

class IActorSystem
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
	template<class cData> void TSetValue(int32 dwOffset, cData Value)
	{
		Write<cData>((dwOffset), Value);
	}
public:
	IActor* GetActor(int32 EntityId)
	{
		int32 v7 = NULL;
		int32 v3 = GetValue<int32>(0x1C);
		int32 v4 = v3;
		int32 v5 = TGetValue<int32>(v3 + 0x4);

		while (!TGetValue<BYTE>(v5 + 0xD))
		{
			if (TGetValue<int32>(v5 + 0x10) >= EntityId)
			{
				v4 = v5;
				v5 = TGetValue<int32>(v5);
			}
			else
			{
				v5 = TGetValue<int32>(v5 + 0x8);
			}
		}

		if (v4 == v3 || (v7 = v4, EntityId < TGetValue<int32>(v4 + 0x10)))
			v7 = v3;

		if (v7 != v3) { return TGetValue<IActor*>((int32)v7 + 0x14); }
		return NULL;
	}

	void CreateActorIterator()
	{
		int32 v3, v5, j, i;
		int32 m_actors_size = GetValue<int32>(0x20);
		v3 = TGetValue<int32>(GetValue<int32>(0x1C));
		while (m_actors_size)
		{
			m_actors_size--;
			m_actors.emplace(TGetValue<int32>(v3 + 0x10), 
			TGetValue<IActor*>(v3 + 0x14));
			if (!TGetValue<BYTE>(v3 + 0xD))
			{
				v5 = TGetValue<int32>(v3 + 0x8);
				if (TGetValue<BYTE>(v5 + 0xD))
				{
					for (i = TGetValue<int32>(v3 + 0x4);
						!TGetValue<BYTE>(i + 0xD); 
						i = TGetValue<int32>(i + 0x4))
					{
						if (v3 != TGetValue<int32>(i + 0x8))
							break;
						v3 = i;

					}
					v3 = i;
				}
				else
				{
					v3 = TGetValue<int32>(v3 + 0x8);
					for (j = TGetValue<int32>(v5); 
						!TGetValue<BYTE>(j + 0xD); 
						j = TGetValue<int32>(j))
						v3 = j;
				}
			}
		}
	}
};

class IEntity
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
	const char* GetStringValue(int32 dwOffset)
	{
		return ReadStringMemoryPtr((uintptr_t)this + dwOffset);
	}
public:
	int32 GetEntityId()
	{
		return GetValue<int32>(IEntityData::GetEntityIdI);
	}

	IEntityClass* GetEntityClass()
	{
		return GetValue<IEntityClass*>(IEntityData::GetEntityClassI);
	}

	Vec3 GetWorldPos()
	{
		return GetValue<Vec3>(0x60);
	}

	int32 GetFlags()
	{
		return GetValue<int32>(0x4);
	}

	int32 GetRawId()
	{
		return GetValue<int32>(0x14);
	}

	Matrix3x4 GetWorldTM()
	{
		return GetValue<Matrix3x4>(0x30);
	}

	Quat GetRotation()
	{
		return GetValue<Quat>(0x78);
	}

	IEntityRenderProxy* GetRenderProxy()
	{
		return TGetValue<IEntityRenderProxy*>(GetValue<int32>(0x9C));
	}

	void SetLocalPos(const Vec3& vPos)
	{
		WriteMemory(((int32)this + 0x30), &GetWorldTM().SetTranslation(vPos), sizeof(f32) * 12);
	}

	const char* GetName()
	{
		return GetStringValue(0xB8);
	}

	int32 GetIntName()
	{
		return GetValue<int32>(0xB8);
	}

	void SetIntName(int32 name)
	{
		SetValue<int32>(0xB8, name);
	}

	ICharacterInstance* GetCharacter(int32 Slot)
	{
		if (int32 GetProxyRenderPtr = (int32)GetRenderProxy())
		{
			int32 Point = TGetValue<int32>(GetProxyRenderPtr + 0x30);
			int32 SlotID = TGetValue<int32>(Point + 0x4 * Slot);
			if (Point && SlotID)
			{
				return TGetValue<ICharacterInstance*>(SlotID + 0x6C);
			}
		}
		return 0;
	}
};

class IEntityClass
{
private:
	const char* GetStringValue(int32 dwOffset)
	{
		return ReadStringMemoryPtr((uintptr_t)this + dwOffset);
	}
public:
	const char* GetName()
	{
		return GetStringValue(0x8);
	}
};

class IEntityRenderProxy
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	void GetWorldBounds(IEntity* pEntity, AABB &aabb)
	{
		aabb = GetValue<AABB>(0x3C);
		aabb.SetTransformedAABB(pEntity->GetWorldTM(), aabb);
	}

	void SetRndFlags(int32 Flag)
	{
		SetValue<int32>((0x14), Flag);
	}

	void SetHUDSilhouettesParams(f32 r, f32 g, f32 b, f32 a)
	{
		int32 m_color = (int32)(f32)(a* 255.0) | (((int32)(f32)(b* 255.0) | (((int32)(f32)(g* 255.0) | ((int32)(f32)(r* 255.0) << 8)) << 8)) << 8);
		SetValue<int32>((0x78), m_color);
	}
};

class ICharacterInstance
{
public:
	ISkeletonPose* GetISkeletonPose()
	{
		return (ISkeletonPose*)(this + 0x748);
	}
};

class ISkeletonPose
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
public:
	QuatT GetAbsJointById(int32 nJointID)
	{
		return TGetValue<QuatT>(GetValue<int32>(0x114) + 0x1C * nJointID);
	}
};

class IActor
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
	template<class cData> void TSetValue(int32 dwOffset, cData Value)
	{
		Write<cData>((dwOffset), Value);
	}	
	int32 GetEncryptValue(int32 dwOffset)
	{
		int32 xor_decdata[2];
		ReadMemory((int32)this + dwOffset, &xor_decdata, sizeof(xor_decdata));
		return xor_decdata[0] ^ xor_decdata[1];
	}
	void SetEncryptValue(int32 dwOffset, f32 fValue)
	{
		Write<int32>((int32)this + dwOffset, *(int32*)& fValue ^ Read<int32>((int32)this + dwOffset + 0x4));
	}
public:
	template<class cData> cData GetFunction(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetFunction(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}

	IEntity* GetEntity()
	{
		return GetValue<IEntity*>(IActorData::GetEntityI);
	}	

	IPlayer* GetPlayer()
	{
		return GetValue<IPlayer*>(IActorData::GetPlayerI);
	}

	int32 GetActorId()
	{
		return GetValue<int32>(IActorData::GetActorIdI);
	}

	int32 GetClassId()
	{
		return GetValue<int32>(IActorData::GetClassIdI);
	}

	int32 GetTeamId()
	{
		return GetValue<int32>(IActorData::GetTeamIdI);
	}

	int32 GetWeaponId()
	{
		return GetValue<int32>(IActorData::WeaponIdI);
	}

	int32 GetCurrentItemId()
	{
		return TGetValue<int32>(GetValue<int32>(0x1C) + 0x68);
	}

	int32 GetHealth()
	{
		f32 fValue = 100.0f;
		*(int32*)&fValue = GetEncryptValue(0x40);
		return fValue;
	}

	int32 GetArmor()
	{
		f32 fValue = 100.0f;
		*(int32*)&fValue = GetEncryptValue(0xBD4);
		return fValue;
	}

	void SetHealth(f32 fValue)
	{
		SetEncryptValue(0x40, fValue);
	}

	void SetArmor(f32 fValue)
	{
		SetEncryptValue(0xBD4, fValue);
	}

	bool IsDead()
	{
		int32 xor_decdata = GetValue<int32>(0x44);
		if (xor_decdata)
		{
			int32 xor_data = xor_decdata ^ GetValue<int32>(0x40);
			return (xor_data != IsDeadFlag::eUnknown && xor_data != IsDeadFlag::eDead);
		}
		return false;
	}

	IWorldQuery* GetWorldQuery()
	{
		int32 ptr_s = GetValue<int32>(0xC);
		if (!ptr_s)
			return nullptr;

		int32 ptr_v = TGetValue<int32>(ptr_s + 0x40);
		if (!ptr_v)
			return nullptr;

		return TGetValue<IWorldQuery*>(ptr_v + 0x18);
	}
};

class IWorldQuery
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	Vec3 GetPos() 
	{ 
		return GetValue<Vec3>(0x20);
	}

	Vec3 GetDir()  
	{ 
		return GetValue<Vec3>(0x2C);
	}

	void SetPos(const Vec3 &vPos)
	{ 
		SetValue(0x20, vPos);
	}

	void SetDir(const Vec3 &vPos) 
	{ 
		SetValue(0x2C, vPos);
	}

	f32 m_proximityRadius() 
	{ 
		return GetValue<f32>(0x1C);
	}

	uint32 m_validQueries()  
	{
		return GetValue<uint32>(0x14); 
	}

	int32 m_renderFrameId()  
	{
		return GetValue<int32>(0x18); 
	}

	EntityId* ProximityQuery(int32 &numberOfEntities)
	{
		ValidateQuery(eWQ_Proximity);
		numberOfEntities = (GetValue<int32>(0x130) - GetValue<int32>(0x12C)) >> 0x2;
		return numberOfEntities ? GetValue<EntityId*>(0x12C) : 0x0;
	}

	EntityId* GetEntitiesAround(int32 &num)
	{
		ValidateQuery(eWQ_EntitiesAround);
		num = (GetValue<int32>(0x24) - GetValue<int32>(0x20)) >> 0x2;
		return num ? GetValue<EntityId*>(0x20) : 0;
	}

    void SetProximityRadius(f32 n)
	{
		SetValue(0x1C, n);
		SetValue<uint32_t>(0x14, m_validQueries() & (eWQ_Proximity | eWQ_InFrontOf));
	}

	ray_hit GetLookAtPoint(f32 fMaxDist = 0, bool ignoreGlass = false)
	{
		ValidateQuery(eWQ_Raycast);
		if (GetValue<BYTE>(0x48))
		{
			ray_hit m_rayHitPierceable = GetValue<ray_hit>(0x8C);
			ray_hit m_rayHitSolid = GetValue<ray_hit>(0x4C);
			ray_hit hit = !ignoreGlass && GetValue<f32>(0x8C) >= 0.f ? m_rayHitPierceable : m_rayHitSolid;
			if ((fMaxDist <= 0) || (hit.dist <= fMaxDist)) { return hit; }
		}
		return ray_hit();
	}

	EntityId GetLookAtEntityId(bool ignoreGlass = false)
	{
		ValidateQuery(eWQ_Raycast);
		return !ignoreGlass && GetValue<f32>(0x8C) >= 0.f ? 0 : GetValue<EntityId>(0x110);
	}

	void ValidateQuery(EWorldQuery query)
	{
		uint32 queryMask = 1u << query;
		int32 frameid = GetValue<int32>(Read<int32>(GameData::dwGlobalAdress) + 0xE4);
		if (m_renderFrameId() != frameid)
		{
			SetValue(0x18, frameid);
			SetValue(0x14, 0);
		}
		else
		{
			if (m_validQueries() & queryMask)
				return;
		}
		SetValue(0x14, m_validQueries() | queryMask);
	}
};

class IPlayer
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	void SetScale(f32 fValue)
	{
		SetValue<f32>((0x8), fValue);
	}

	void SetRecoilMult(int8 iValue)
	{
		SetValue<int8>((0xB1), iValue);
	}

	Quat GetViewRotation()
	{
		return GetValue<Quat>(0x80);
	}

	void SetViewRotation(Quat &rotation)
	{
		SetValue<Quat>((0xA0), rotation);
		SetValue<Quat>((0x80), rotation);
		SetValue<Quat>((0x90), rotation);
	}
};

class IItemSystem
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
public:
	static IItemSystem* Singleton()
	{
		return Read<IItemSystem*>(GameData::dwBaseIItemSystem);
	}

	IItem* GetItem(int32 itemId)
	{
		int32 v7 = NULL;
		int32 v3 = GetValue<int32>(0x40);
		int32 v4 = v3;
		int32 v5 = TGetValue<int32>(v3 + 0x4);

		while (!TGetValue<BYTE>(v5 + 0xD))
		{
			if (TGetValue<int32>(v5 + 0x10) >= itemId)
			{
				v4 = v5;
				v5 = TGetValue<int32>(v5);
			}
			else
			{
				v5 = TGetValue<int32>(v5 + 0x8);
			}
		}

		if (v4 == v3 || (v7 = v4, itemId < TGetValue<int32>(v4 + 0x10)))
			v7 = v3;

		if (v7 != v3)
			return TGetValue<IItem*>(v7 + 0x14);

		return NULL;
	}
};

class IItem
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
public:
	IWeapon* GetWeapon()
	{
		return (IWeapon*)(this + 0x14);
	}

	IEntity* GetEntity()
	{
		return GetValue<IEntity*>(0x8);
	}
};

class IWeapon
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void TSetValue(int32 dwOffset, cData Value)
	{
		Write<cData>((dwOffset), Value);
	}
public:
	IWeaponSpecific* GetWeaponSpecific()
	{
		return GetValue<IWeaponSpecific*>(IWeaponSpecificI);
	}

	void SetFiringPos(Vec3 VectorValue)
	{
		int32 ptr_s = GetValue<int32>(0xC);
		if (!ptr_s)
			return;

		TSetValue<Vec3>((ptr_s + SetFiringPosI), VectorValue);
	}
};

class IWeaponSpecific
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	IWeaponExtra* GetWeaponExtra()
	{
		return GetValue<IWeaponExtra*>(IWeaponData::IWeaponExtraI);
	}

	IWeaponCrypt* GetWeaponCrypt()
	{
		return GetValue<IWeaponCrypt*>(IWeaponData::IWeaponCryptI);
	}

	IWeaponAmmo* GetWeaponAmmo()
	{
		return GetValue<IWeaponAmmo*>(IWeaponData::IWeaponAmmoI);
	}

	void Shutter(int8 iValue)
	{
		SetValue<int8>((IWeaponData::ShutterI), iValue);
	}

	int32 GetWeaponStance()
	{
		return GetValue<int32>(IWeaponData::GetWeaponStanceI);
	}

	void StartFire()
	{
		SetValue<int32>((0xF4), GetValue<int32>(0xF8));
	}

	void StopFire()
	{
		SetValue<int32>((0xF4), GetValue<int32>(0xF0));
	}
};

class IWeaponExtra
{
private:
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	void SetDamage(int32 iValue)
	{
		SetValue<int32>((IWeaponData::DamageI), iValue);
	}
};

class IWeaponCrypt
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
	template<class cData> void TSetValue(int32 dwOffset, cData Value)
	{
		Write<cData>((dwOffset), Value);
	}
public:
	void SetSway(Vec3 VectorValue)
	{
		SetValue<Vec3>((0x0), VectorValue);
	}

	int32 GetCrypt(int32 Id)
	{
		int32 result;
		int32 v3 = GetValue<int32>(0x6C);
		int32 v5 = TGetValue<int32>(v3 + 0x4);
		while (!TGetValue<BYTE>(v5 + 0xD))
		{
			int32 EntityId = TGetValue<int32>(v5 + 0x10);
			if (EntityId == Id) break;
			else if (EntityId < Id) v5 = TGetValue<int32>(v5 + 0x8);
			else v5 = TGetValue<int32>(v5);
		}
		if (TGetValue<int32>(v5 + 0x10) == Id)
		{
			result = v5;
		}
		return result;
	}

	bool GetEncryptValue(int32 Id, f32* fValue)
	{
		bool result = false;
		int32 xor_decdata[2];
		ReadMemory(GetCrypt(Id) + 0x14, &xor_decdata, sizeof(xor_decdata));
		result = *(int32*)fValue = xor_decdata[0] ^ xor_decdata[1];
		return result;
	}

	void SetCryptValue(int32 Id, f32 fValue)
	{
		TSetValue<int32>(GetCrypt(Id) + 0x14, *(int32*)&fValue ^ Read<int32>(GetCrypt(Id) + 0x18));
	}
};

class IWeaponAmmo
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	void UnlimitedAmmo(bool bForce)
	{
		SetValue<int32>((0x0), bForce);
	}

	int32 GetAmmoCount()
	{
		return GetValue<int32>(0x4);
	}

	void SetAmmoCount(int32 iValue)
	{
		SetValue<int32>((0x4), iValue);
	}
};

class IGameRules
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
public:
	int32 GetTeamCount()
	{
		return GetValue<int32>(0x88);
	}
};

class IGameFramework
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> cData TGetValue(int32 dwOffset)
	{
		return Read<cData>(dwOffset);
	}
public:
	static IGameFramework* Singleton()
	{
		return Read<IGameFramework*>(GameData::dwBaseGameFrameWork);
	}

	IGameRules* GetGameRules()
	{
		return GetValue<IGameRules*>(0x618);
	}

	IActorSystem* GetActorSystem()
	{
		return GetValue<IActorSystem*>(0x4B0);
	}

	IEntitySystem* GetEntitySystem()
	{
		return GetValue<IEntitySystem*>(0x18);
	}

	int32 GetClientActorId()
	{
		int32 v3 = 0;
		int32 v4 = 0;
		int32 v8 = GetValue<int32>(0x28);
		if (v8)
		{
			int32 v2 = TGetValue<int32>(v8 + 0x24);
			if (v2)
				v3 = TGetValue<int32>(v2 + 0x8);
			else
				v3 = 0;

			if (v3)
			{
				v4 = TGetValue<int32>(v3 + 0x10);
			}
		}
		return v4;
	}

	IActor* GetClientActor(TActorMap m_actors)
	{
		TActorMap::iterator it = m_actors.find(GetClientActorId());
		if (it != m_actors.end()) return it->second;
		return 0;
	}
};

class ICVar
{
private:
	template<class cData> cData GetValue(int32 dwOffset)
	{
		return Read<cData>((int32)this + dwOffset);
	}
	template<class cData> void SetValue(int32 dwOffset, cData Value)
	{
		Write<cData>(((int32)this + dwOffset), Value);
	}
public:
	static ICVar* Singleton()
	{
		return Read<ICVar*>(GameData::dwBaseGameCVar);
	}

	template<class cData> cData GetCVar(int32 dwOffset)
	{
		return GetValue<cData>(dwOffset);
	}

	template<class cData> void SetCVar(int32 dwOffset, cData Value)
	{
		SetValue<cData>((dwOffset), Value);
	}
};

#pragma once
#include <windows.h>
#include <cmath>
#include <d3d9.h>
#include <vector>

#ifdef _DEBUG
#define ILINE _inline
#else
#define ILINE __forceinline
#endif
enum type_zero { ZERO };
enum type_min { VMIN };
enum type_max { VMAX };
enum type_identity { IDENTITY };
typedef signed char      int8;
typedef signed short     int16;
typedef signed int		 int32;
typedef signed __int64	 int64;
typedef unsigned char	 uint8;
typedef unsigned short	 uint16;
typedef unsigned int	 uint32;
typedef unsigned __int64 uint64;
typedef float f32;
typedef double f64;
typedef unsigned int EntityId;
ILINE f32 cry_fabsf(f32 x) { return fabsf(x); }
ILINE f32 cry_isqrtf(f32 x) { return 1.f / sqrtf(x); }
ILINE f64 isqrt_tpl(f64 op) { return 1.0 / sqrt(op); }
ILINE f32 isqrt_tpl(f32 op) { return cry_isqrtf(op); }
ILINE f64 fabs_tpl(f64 op) { return fabs(op); }
ILINE f32 fabs_tpl(f32 op) { return cry_fabsf(op); }
float isqrt_safe_tpl(float op) { return 1.0 / sqrt(op + DBL_MIN); }
#define assert(expression) ((void)0)
#define FloatU32(x)		 (*( (uint32*) &(x) ))
#define FloatU32ExpMask	 (0xFF << 23)
void cry_sincos(float angle, float* pSin, float* pCos) { *pSin = (sin(angle));  *pCos = (cos(angle)); }
void sincos(float angle, float* pSin, float* pCos) { cry_sincos(angle, pSin, pCos); }
f32 fZero = 0.000f;

struct Vec3
{
public:
	FLOAT x, y, z;
	Vec3(type_zero) : x(0), y(0), z(0) {}
	Vec3() { Vec3(0.f, 0.f, 0.f); }
	Vec3(FLOAT x, FLOAT y, FLOAT z)
	{
		this->x = x;
		this->y = y;
		this->z = z;
	}
	FLOAT length() const { return sqrt(x*x + y * y + z * z); }
	FLOAT Distance(Vec3 &VecB)
	{
		Vec3 Out = *this - VecB;
		return sqrt(Out.x*Out.x + Out.y*Out.y + Out.z*Out.z);
	}
	Vec3 PZD(Vec3 &VecB)
	{
		Vec3 Out = *this - VecB;
		return Out / sqrt(Out.x*Out.x + Out.y*Out.y + Out.z*Out.z);
	}
	VOID Set(FLOAT x, FLOAT y, FLOAT z)
	{
		this->x = x;
		this->y = y;
		this->z = z;
	}
	void Normalize()
	{
		assert(this->IsValid());
		float fInvLen = isqrt_safe_tpl(x*x + y * y + z * z);
		x *= fInvLen; y *= fInvLen; z *= fInvLen;
	}
	bool NumberValid(const float& x)
	{
		uint32 i = FloatU32(x);
		uint32 expmask = FloatU32ExpMask;
		uint32 iexp = i & expmask;
		bool invalid = (iexp == expmask);
		if (invalid)
		{
			union f32_u
			{
				uint32 uintVal;
				f32 floatVal;
			};
			f32_u u;	u.uintVal = 0x7F800001;
			float fpe = u.floatVal;
			(void)fpe;
		}
		return !invalid;
	}
	bool IsValid()
	{
		if (!NumberValid(x)) return false;
		if (!NumberValid(y)) return false;
		if (!NumberValid(z)) return false;
		return true;
	}
	Vec3& normalize()
	{
		FLOAT len2 = x * x + y * y + z * z;
		if (len2 > 1e-20f)
		{
			FLOAT rlen = (float)1.0 / sqrt(len2);
			x *= rlen; y *= rlen; z *= rlen;
		}
		else { x = 0; y = 0; z = 1; }
		return *this;
	}
	Vec3& FastNormalize()
	{
		FLOAT l = length();
		l = 1.f / l;
		this->x *= l;
		this->y *= l;
		this->z *= l;
		return *this;
	}
	Vec3 GetNormalized() const
	{
		float fInvLen = isqrt_safe_tpl(x*x + y * y + z * z);
		Vec3 out = *this;
		out.x *= fInvLen;
		out.y *= fInvLen;
		out.z *= fInvLen;
		return out;
	}
	Vec3 GetNormalizedSafe(const struct Vec3& safe) const
	{
		float fLen2 = x * x + y * y + z * z;
		if (fLen2 > 0.0f)
		{
			float fInvLen = isqrt_tpl(fLen2);
			Vec3 out;
			out.x = safe.x*fInvLen;
			out.y = safe.y*fInvLen;
			out.z = safe.z*fInvLen;
			return out;
		}
		else { return safe; }
	}
	FLOAT len2() { return x * x + y * y + z * z; }
	FLOAT len() { return sqrt(x*x + y * y + z * z); }
	Vec3 operator / (FLOAT fValue) { return Vec3(x / fValue, y / fValue, z / fValue); }
	Vec3& operator /= (FLOAT fValue)
	{
		*this = *this / fValue;
		return *this;
	}
	Vec3 operator / (FLOAT fValue) const
	{
		Vec3 vOut;
		vOut.x = this->x / fValue;
		vOut.y = this->y / fValue;
		vOut.z = this->z / fValue;
		return vOut;
	}
	BOOL operator != (Vec3 &vec) { return !(vec.x == x && vec.y == y && vec.z == z); }
	BOOL operator == (Vec3 &vec) { return (vec.x == x && vec.y == y && vec.z == z); }
	Vec3 operator /  (Vec3 &vec) const { return Vec3(vec.x / x, vec.y / y, vec.z / z); }
	Vec3 operator +  (Vec3 &vec) const { return Vec3(vec.x + x, vec.y + y, vec.z + z); }
	Vec3 operator *  (Vec3 &vec) const { return Vec3(vec.x * x, vec.y * y, vec.z * z); }
	Vec3 operator *  (FLOAT fValue) const { return Vec3(x*fValue, y*fValue, z*fValue); }
	Vec3 operator -  (Vec3 &vec) const { return Vec3(vec.x - x, vec.y - y, vec.z - z); }
	VOID CheckMin(Vec3 &other)
	{
		x = min(other.x, x);
		y = min(other.y, y);
		z = min(other.z, z);
	}
	VOID CheckMax(Vec3 &other)
	{
		x = max(other.x, x);
		y = max(other.y, y);
		z = max(other.z, z);
	}
	Vec3(f32 f) : x(f), y(f), z(f) { assert(this->IsValid()); }
};
struct Vec4 
{
	Vec4() {}
	f32 x, y, z, w;
};
struct Matrix3x3
{
	Matrix3x3(const Vec3& vx, const Vec3& vy, const Vec3& vz)
	{
		m00 = (vx.x);
		m01 = (vy.x);
		m02 = (vz.x);

		m10 = (vx.y);
		m11 = (vy.y);
		m12 = (vz.y);

		m20 = (vx.z);
		m21 = (vy.z);
		m22 = (vz.z);
	}
	Matrix3x3() { m00 = m01 = m02 = m10 = m11 = m12 = m20 = m21 = m22 = 0.f; };
	void SetRotationVDir(const Vec3& vdir)
	{
		m00 = 1;
		m01 = 0;
		m02 = 0;
		m10 = 0;
		m11 = 0;
		m12 = -vdir.z;
		m20 = 0;
		m21 = vdir.z;
		m22 = 0;
		float l = sqrt(vdir.x*vdir.x + vdir.y*vdir.y);
		if (l > 0.0001)
		{
			float xl = -vdir.x / l;
			float yl = vdir.y / l;

			m00 = (yl);
			m01 = (vdir.x);
			m02 = (xl*vdir.z);

			m10 = (xl);
			m11 = (vdir.y);
			m12 = (-vdir.z*yl);

			m20 = 0;
			m21 = (vdir.z);
			m22 = (l);
		}
	}
	Vec3 operator *(Vec3& v) { return Vec3(v.x*m00 + v.y*m01 + v.z*m02, v.x*m10 + v.y*m11 + v.z*m12, v.x*m20 + v.y*m21 + v.z*m22); }
	float m00, m01, m02;
	float m10, m11, m12;
	float m20, m21, m22;
};
struct Quat
{
public:
	Vec3 v;
	FLOAT w;
	Quat(const Matrix3x3& m)
	{
		float s, p, tr = m.m00 + m.m11 + m.m22;
		w = 1, v.x = 0, v.y = 0, v.z = 0;

		if (tr>0)
			s = (float)sqrt(tr + 1.0f), p = 0.5f / s, w = s * 0.5f, v.x = (m.m21 - m.m12)*p, v.y = (m.m02 - m.m20)*p, v.z = (m.m10 - m.m01)*p;
		else if ((m.m00 >= m.m11) && (m.m00 >= m.m22))
			s = (float)sqrt(m.m00 - m.m11 - m.m22 + 1.0f), p = 0.5f / s, w = (m.m21 - m.m12)*p, v.x = s * 0.5f, v.y = (m.m10 + m.m01)*p, v.z = (m.m20 + m.m02)*p;
		else if ((m.m11 >= m.m00) && (m.m11 >= m.m22))
			s = (float)sqrt(m.m11 - m.m22 - m.m00 + 1.0f), p = 0.5f / s, w = (m.m02 - m.m20)*p, v.x = (m.m01 + m.m10)*p, v.y = s * 0.5f, v.z = (m.m21 + m.m12)*p;
		else if ((m.m22 >= m.m00) && (m.m22 >= m.m11))
			s = (float)sqrt(m.m22 - m.m00 - m.m11 + 1.0f), p = 0.5f / s, w = (m.m10 - m.m01)*p, v.x = (m.m02 + m.m20)*p, v.y = (m.m12 + m.m21)*p, v.z = s * 0.5f;
	}
	Quat() {}
	friend float operator | (const Quat& q, const Quat& p) { return (q.v.x*p.v.x + q.v.y*p.v.y + q.v.z*p.v.z + q.w*p.w); }
	friend Quat  operator - (const Quat &q, const Quat &p)
	{
		Quat ret;
		ret.w = q.w - p.w;

		ret.v.x = q.v.x - p.v.x;
		ret.v.y = q.v.y - p.v.y;
		ret.v.z = q.v.z - p.v.z;

		return ret;
	}
	void        SetRotationVDir(const Vec3& vdir)
	{
		w = (0.70710676908493042f);
		v.x = (vdir.z*0.70710676908493042f);
		v.y = (0.0f);
		v.z = (0.0f);

		float l = sqrt(vdir.x*vdir.x + vdir.y*vdir.y);

		if (l > (0.00001))
		{
			Vec3 hv;

			hv.x = vdir.x / l;
			hv.y = vdir.y / l + 1.0f;
			hv.z = l + 1.0f;

			float r = sqrt(hv.x*hv.x + hv.y*hv.y);
			float s = sqrt(hv.z*hv.z + vdir.z*vdir.z);
			float hacos0 = 0.0;
			float hasin0 = -1.0;

			if (r > (0.00001)) { hacos0 = hv.y / r; hasin0 = -hv.x / r; }

			float hacos1 = hv.z / s;
			float hasin1 = vdir.z / s;

			w = (hacos0*hacos1);
			v.x = (hacos0*hasin1);
			v.y = (hasin0*hasin1);
			v.z = (hasin0*hacos1);
		}
	}
	static Quat CreateRotationVDir(const Vec3& vdir)
	{
		Quat q;
		q.SetRotationVDir(vdir);
		return q;
	}
	void Normalize(void)
	{
		float d = sqrt(w*w + v.x*v.x + v.y*v.y + v.z*v.z);

		w *= d;

		v.x *= d;
		v.y *= d;
		v.z *= d;
	}
	void SetNlerp(const Quat &p, const Quat &tq, float t)
	{
		Quat q = tq;

		assert(p.IsValid());
		assert(q.IsValid());

		if ((p | q) < 0)
		{
			float qx = -q.v.x;
			float qy = -q.v.y;
			float qz = -q.v.z;

			q.v.x = qx;
			q.v.y = qy;
			q.v.z = qz;
		}

		v.x = p.v.x*(1.0f - t) + q.v.x*t;
		v.y = p.v.y*(1.0f - t) + q.v.y*t;
		v.z = p.v.z*(1.0f - t) + q.v.z*t;

		w = p.w  *(1.0f - t) + q.w  *t;

		Normalize();
	}
	void SetSlerp(const Quat &tp, const Quat &tq, float t)
	{
		assert(tp.IsValid());
		Quat p, q;
		p = tp;
		q = tq;
		Quat q2;
		float cosine = (p | q);
		if (cosine < 0.0f)
		{
			float qx = -q.v.x;
			float qy = -q.v.y;
			float qz = -q.v.z;

			cosine = -cosine;

			q.v.x = qx;
			q.v.y = qy;
			q.v.z = qz;
		}
		if (cosine > 0.9999f)
		{
			SetNlerp(p, q, t);
			return;
		}
		q2.w = q.w - p.w*cosine;
		q2.v.x = q.v.x - p.v.x*cosine;
		q2.v.y = q.v.y - p.v.y*cosine;
		q2.v.z = q.v.z - p.v.z*cosine;
		float sine = sqrt(q2 | q2);
		float s, c;
		sincos(atan2(sine, cosine)*t, &s, &c);
		w = (p.w*c + q2.w*s / sine);
		v.x = (p.v.x*c + q2.v.x*s / sine);
		v.y = (p.v.y*c + q2.v.y*s / sine);
		v.z = (p.v.z*c + q2.v.z*s / sine);
	}
	static Quat CreateSlerp(const Quat &p, const Quat &tq, float t)
	{
		Quat d;
		d.SetSlerp(p, tq, t);
		return d;
	}
};
struct QuatT
{
public:
	Quat q;
	Vec3 t;
};
struct Matrix3x4
{
public:
	FLOAT m00, m01, m02, m03;
	FLOAT m10, m11, m12, m13;
	FLOAT m20, m21, m22, m23;
	Vec3 GetTranslation() { Vec3 mf; mf.x = m03; mf.y = m13; mf.z = m23; return Vec3(mf); }
	Vec3 GetTranslation_() { Vec3 mf; mf.x = m03; mf.y = m13; mf.z = m23; return mf; }
	inline Vec3 GetTranslationD3D() const { return Vec3(m03, m13, m23); }
	inline Vec3 GetColumn0() const { return Vec3(m00, m10, m20); }
	inline Vec3 GetColumn1() const { return Vec3(m01, m11, m21); }
	BOOL NumberValid(FLOAT &_x)
	{
		int i = FloatU32(_x);
		int expmask = FloatU32ExpMask;
		int iexp = i & expmask;
		bool invalid = (iexp == expmask);

		if (invalid)
		{
			int i = 0x7F800001;
			float fpe = *(float*)(&i);
		}

		return !invalid;
	}
	Matrix3x4 SetTranslation(Vec3 NewTranslation) { m03 = NewTranslation.x; m13 = NewTranslation.y; m23 = NewTranslation.z; return *this; }
	Matrix3x4() {}
	Matrix3x4(QuatT& q)
	{
		assert(q.q.IsValid());
		Vec3 v2;
		v2.x = (q.q.v.x) + (q.q.v.x);
		float xx = 1 - v2.x*q.q.v.x; float yy = v2.y*q.q.v.y; float xw = v2.x*q.q.w;
		float xy = v2.y*q.q.v.x;   float yz = v2.z*q.q.v.y; float  yw = v2.y*q.q.w;
		float xz = v2.z*q.q.v.x;   float zz = v2.z*q.q.v.z; float  zw = v2.z*q.q.w;
		m00 = float(1 - yy - zz);     m01 = float(xy - zw);     m02 = float(xz + yw);   m03 = float(q.t.x);
		m10 = float(xy + zw);      m11 = float(xx - zz);     m12 = float(yz - xw);   m13 = float(q.t.y);
		m20 = float(xz - yw);      m21 = float(yz + xw);     m22 = float(xx - yy);   m23 = float(q.t.z);
	}
	bool IsValid()
	{
		if (!NumberValid(m00)) return false;	if (!NumberValid(m01)) return false;	if (!NumberValid(m02)) return false;	if (!NumberValid(m03)) return false;
		if (!NumberValid(m10)) return false;	if (!NumberValid(m11)) return false;	if (!NumberValid(m12)) return false;	if (!NumberValid(m13)) return false;
		if (!NumberValid(m20)) return false;	if (!NumberValid(m21)) return false;	if (!NumberValid(m22)) return false;	if (!NumberValid(m23)) return false;
		return true;
	}
	friend Matrix3x4 operator * (Matrix3x4& l, Matrix3x4& r)
	{
		assert(l.IsValid());
		assert(r.IsValid());
		Matrix3x4 m = r;
		m.m00 = l.m00*r.m00 + l.m01*r.m10 + l.m02*r.m20;
		m.m10 = l.m10*r.m00 + l.m11*r.m10 + l.m12*r.m20;
		m.m20 = l.m20*r.m00 + l.m21*r.m10 + l.m22*r.m20;
		m.m01 = l.m00*r.m01 + l.m01*r.m11 + l.m02*r.m21;
		m.m11 = l.m10*r.m01 + l.m11*r.m11 + l.m12*r.m21;
		m.m21 = l.m20*r.m01 + l.m21*r.m11 + l.m22*r.m21;
		m.m02 = l.m00*r.m02 + l.m01*r.m12 + l.m02*r.m22;
		m.m12 = l.m10*r.m02 + l.m11*r.m12 + l.m12*r.m22;
		m.m22 = l.m20*r.m02 + l.m21*r.m12 + l.m22*r.m22;
		m.m03 = l.m00*r.m03 + l.m01*r.m13 + l.m02*r.m23 + l.m03;
		m.m13 = l.m10*r.m03 + l.m11*r.m13 + l.m12*r.m23 + l.m13;
		m.m23 = l.m20*r.m03 + l.m21*r.m13 + l.m22*r.m23 + l.m23;
		return m;
	}
	Vec3 operator *(Vec3& p)
	{
		Vec3 tp;
		tp.x = m00 * p.x + m01 * p.y + m02 * p.z + m03;
		tp.y = m10 * p.x + m11 * p.y + m12 * p.z + m13;
		tp.z = m20 * p.x + m21 * p.y + m22 * p.z + m23;
		return	tp;
	}
};
template<typename F> struct Matrix44_tpl 
{
	F m00, m01, m02, m03;
	F m10, m11, m12, m13;
	F m20, m21, m22, m23;
	F m30, m31, m32, m33;

	ILINE Matrix44_tpl() {};
	ILINE void SetZero() {
		m00 = 0;
		m01 = 0;
		m02 = 0;
		m03 = 0;
		m10 = 0;
		m11 = 0;
		m12 = 0;
		m13 = 0;
		m20 = 0;
		m21 = 0;
		m22 = 0;
		m23 = 0;
		m30 = 0;
		m31 = 0;
		m32 = 0;
		m33 = 0;
	}
	ILINE Matrix44_tpl(type_zero) { SetZero(); }

	ILINE void SetIdentity()
	{
		m00 = 1;
		m01 = 0;
		m02 = 0;
		m03 = 0;
		m10 = 0;
		m11 = 1;
		m12 = 0;
		m13 = 0;
		m20 = 0;
		m21 = 0;
		m22 = 1;
		m23 = 0;
		m30 = 0;
		m31 = 0;
		m32 = 0;
		m33 = 1;
	}
	ILINE Matrix44_tpl(type_identity) { SetIdentity(); }
};

#define CRY_ALIGN(bytes) __declspec(align(bytes))
typedef Matrix44_tpl<f32>		Matrix44;
typedef CRY_ALIGN(16) Matrix44_tpl<f32> Matrix44A;

struct AABB
{
	Vec3 min;
	Vec3 max;
	BOOL IsReset() { return min.x > max.x; }
	VOID Reset() { min = Vec3(1e35f);	max = Vec3(-1e35f); }
	VOID SetTransformedAABB(Matrix3x4& m34, AABB& aabb)
	{
		if (aabb.IsReset()) Reset();
		else
		{
			Matrix3x3 m33;
			m33.m00 = fabs_tpl(m34.m00);
			m33.m01 = fabs_tpl(m34.m01);
			m33.m02 = fabs_tpl(m34.m02);
			m33.m10 = fabs_tpl(m34.m10);
			m33.m11 = fabs_tpl(m34.m11);
			m33.m12 = fabs_tpl(m34.m12);
			m33.m20 = fabs_tpl(m34.m20);
			m33.m21 = fabs_tpl(m34.m21);
			m33.m22 = fabs_tpl(m34.m22);

			Vec3 sz = m33 * ((aabb.max - aabb.min)*0.5f);
			Vec3 pos = m34 * ((aabb.max + aabb.min)*0.5f);
			min = pos - sz;
			max = pos + sz;
		}
	}
};

#define RBPF_REVERSE_DEPTH (1 << 27)
inline void mathVec4Transform(f32 out[4], const f32 m[16], const f32 in[4])
{
#define M(row, col) m[col * 4 + row]
	out[0] = M(0, 0) * in[0] + M(0, 1) * in[1] + M(0, 2) * in[2] + M(0, 3) * in[3];
	out[1] = M(1, 0) * in[0] + M(1, 1) * in[1] + M(1, 2) * in[2] + M(1, 3) * in[3];
	out[2] = M(2, 0) * in[0] + M(2, 1) * in[1] + M(2, 2) * in[2] + M(2, 3) * in[3];
	out[3] = M(3, 0) * in[0] + M(3, 1) * in[1] + M(3, 2) * in[2] + M(3, 3) * in[3];
#undef M
}

ILINE f32 __mathVec3Project(Vec3* pvWin, const Vec3* pvObj, const int32 pViewport[4], const Matrix44* pProjection, const Matrix44* pView, const Matrix44* pWorld)
{
	Vec4 in, out;
	in.x = pvObj->x;
	in.y = pvObj->y;
	in.z = pvObj->z;
	in.w = 1.0f;
	mathVec4Transform((f32*)&out, (f32*)pWorld, (f32*)&in);
	mathVec4Transform((f32*)&in, (f32*)pView, (f32*)&out);
	mathVec4Transform((f32*)&out, (f32*)pProjection, (f32*)&in);
	if (out.w == 0.0f) return 0.f;
	out.x /= out.w;
	out.y /= out.w;
	out.z /= out.w;
	pvWin->x = pViewport[0] + (1 + out.x) * pViewport[2] / 2;
	pvWin->y = pViewport[1] + (1 - out.y) * pViewport[3] / 2;
	float fViewportMinZ = 0, fViewportMaxZ = 1.0f;
	pvWin->z = fViewportMinZ + out.z * (fViewportMaxZ - fViewportMinZ);
	return out.w;
}