kal

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/ccsgoinput.h

@@ -0,0 +1,95 @@
+#pragma once
+
+// used: mem_pad
+#include "../../utilities/memory.h"
+
+// used: cusercmd
+#include "../datatypes/usercmd.h"
+
+#define MULTIPLAYER_BACKUP 150
+
+class CTinyMoveStepData
+{
+public:
+	float flWhen; //0x0000
+	MEM_PAD(0x4); //0x0004
+	std::uint64_t nButton; //0x0008
+	bool bPressed; //0x0010
+	MEM_PAD(0x7); //0x0011
+}; //Size: 0x0018
+
+class CMoveStepButtons
+{
+public:
+	std::uint64_t nKeyboardPressed; //0x0000
+	std::uint64_t nMouseWheelheelPressed; //0x0008
+	std::uint64_t nUnPressed; //0x0010
+	std::uint64_t nKeyboardCopy; //0x0018
+}; //Size: 0x0020
+
+// @credits: www.unknowncheats.me/forum/members/2943409.html
+class CExtendedMoveData : public CMoveStepButtons
+{
+public:
+	float flForwardMove; //0x0020
+	float flSideMove; //0x0024
+	float flUpMove; //0x0028
+	std::int32_t nMouseDeltaX; //0x002C
+	std::int32_t nMouseDeltaY; //0x0030
+	std::int32_t nAdditionalStepMovesCount; //0x0034
+	CTinyMoveStepData tinyMoveStepData[12]; //0x0038
+	Vector_t vecViewAngle; //0x0158
+	std::int32_t nTargetHandle; //0x0164
+}; //Size:0x0168
+
+class CCSGOInput
+{
+public:
+	MEM_PAD(0x250);
+	CUserCmd arrCommands[MULTIPLAYER_BACKUP];
+	MEM_PAD(0x99)
+	bool bInThirdPerson;
+	MEM_PAD(0x6);
+	QAngle_t angThirdPersonAngles;
+	MEM_PAD(0xE);
+	std::int32_t nSequenceNumber;
+	double dbSomeTimer;
+	CExtendedMoveData currentMoveData;
+	std::int32_t nWeaponSwitchTick;
+	MEM_PAD(0x1C4);
+	CExtendedMoveData* pExtendedMoveData;
+	MEM_PAD(0x48);
+	int32_t nAttackStartHistoryIndex1;
+	int32_t nAttackStartHistoryIndex2;
+	int32_t nAttackStartHistoryIndex3;
+
+	CUserCmd* GetUserCmd()
+	{
+		return &arrCommands[nSequenceNumber % MULTIPLAYER_BACKUP];
+	}
+
+	void SetViewAngle(QAngle_t& angView)
+	{
+		// @ida: this got called before GetMatricesForView
+		using fnSetViewAngle = std::int64_t(CS_FASTCALL*)(void*, std::int32_t, QAngle_t&);
+		static auto oSetViewAngle = reinterpret_cast<fnSetViewAngle>(MEM::FindPattern(CLIENT_DLL, CS_XOR("85 D2 75 3F 48")));
+
+		#ifdef CS_PARANOID
+		CS_ASSERT(oSetViewAngle != nullptr);
+		#endif
+
+		oSetViewAngle(this, 0, std::ref(angView));
+	}
+
+	QAngle_t GetViewAngles()
+	{
+		using fnGetViewAngles = std::int64_t(CS_FASTCALL*)(CCSGOInput*, std::int32_t);
+		static auto oGetViewAngles = reinterpret_cast<fnGetViewAngles>(MEM::FindPattern(CLIENT_DLL, CS_XOR("4C 8B C1 85 D2 74 08 48 8D 05 ? ? ? ? C3")));
+
+		#ifdef CS_PARANOID
+		CS_ASSERT(oGetViewAngles != nullptr);
+		#endif
+
+		return *reinterpret_cast<QAngle_t*>(oGetViewAngles(this, 0));
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/cgameentitysystem.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// used: schema field
+#include "../../utilities/memory.h"
+
+#include "../entity_handle.h"
+
+#define MAX_ENTITIES_IN_LIST 512
+#define MAX_ENTITY_LISTS 64 // 0x3F
+#define MAX_TOTAL_ENTITIES MAX_ENTITIES_IN_LIST* MAX_ENTITY_LISTS
+
+class C_BaseEntity;
+
+class CGameEntitySystem
+{
+public:
+	/// GetClientEntity
+	template <typename T = C_BaseEntity>
+	T* Get(int nIndex)
+	{
+		return reinterpret_cast<T*>(this->GetEntityByIndex(nIndex));
+	}
+
+	/// GetClientEntityFromHandle
+	template <typename T = C_BaseEntity>
+	T* Get(const CBaseHandle hHandle)
+	{
+		if (!hHandle.IsValid())
+			return nullptr;
+
+		return reinterpret_cast<T*>(this->GetEntityByIndex(hHandle.GetEntryIndex()));
+	}
+
+	int GetHighestEntityIndex()
+	{
+		return *reinterpret_cast<int*>(reinterpret_cast<std::uintptr_t>(this) + 0x1510);
+	}
+
+private:
+	void* GetEntityByIndex(int nIndex)
+	{
+		//@ida: #STR: "(missing),", "(missing)", "Ent %3d: %s class %s name %s\n" | or find "cl_showents" cvar -> look for callback
+		//	do { pEntity = GetBaseEntityByIndex(g_pGameEntitySystem, nCurrentIndex); ... }
+		using fnGetBaseEntity = void*(CS_THISCALL*)(void*, int);
+		static auto GetBaseEntity = reinterpret_cast<fnGetBaseEntity>(MEM::FindPattern(CLIENT_DLL, CS_XOR("81 FA ? ? ? ? 77 ? 8B C2 C1 F8 ? 83 F8 ? 77 ? 48 98 48 8B 4C C1 ? 48 85 C9 74 ? 8B C2 25 ? ? ? ? 48 6B C0 ? 48 03 C8 74 ? 8B 41 ? 25 ? ? ? ? 3B C2 75 ? 48 8B 01")));
+		return GetBaseEntity(this, nIndex);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/cgametracemanager.cpp

@@ -0,0 +1,59 @@
+// used: game trace manager
+#include "cgametracemanager.h"
+// used: c_csplayerpawn
+#include "../../sdk/entity.h"
+
+SurfaceData_t* GameTrace_t::GetSurfaceData()
+{
+	using fnGetSurfaceData = std::uint64_t(__fastcall*)(void*);
+	static fnGetSurfaceData oGetSurfaceData = reinterpret_cast<fnGetSurfaceData>(MEM::GetAbsoluteAddress(MEM::FindPattern(CLIENT_DLL, CS_XOR("E8 ? ? ? ? 48 85 C0 74 ? 44 38 60")), 0x1, 0x0));
+
+#ifdef CS_PARANOID
+	CS_ASSERT(oGetSurfaceData != nullptr);
+#endif
+
+	return reinterpret_cast<SurfaceData_t*>(oGetSurfaceData(m_pSurface));
+}
+
+int GameTrace_t::GetHitboxId()
+{
+	if (m_pHitboxData)
+		return m_pHitboxData->m_nHitboxId;
+	return 0;
+}
+
+int GameTrace_t::GetHitgroup()
+{
+	if (m_pHitboxData)
+		return m_pHitboxData->m_nHitGroup;
+	return 0;
+}
+
+bool GameTrace_t::IsVisible() const
+{
+	return (m_flFraction > 0.97f);
+}
+
+TraceFilter_t::TraceFilter_t(std::uint64_t uMask, C_CSPlayerPawn* pSkip1, C_CSPlayerPawn* pSkip2, int nLayer)
+{
+	m_uTraceMask = uMask;
+	m_v1[0] = m_v1[1] = 0;
+	m_v2 = 7;
+	m_v3 = nLayer;
+	m_v4 = 0x49;
+	m_v5 = 0;
+
+	if (pSkip1 != nullptr)
+	{
+		m_arrSkipHandles[0] = pSkip1->GetRefEHandle().GetEntryIndex();
+		m_arrSkipHandles[2] = pSkip1->GetOwnerHandleIndex();
+		m_arrCollisions[0] = pSkip1->GetCollisionMask();
+	}
+
+	if (pSkip2 != nullptr)
+	{
+		m_arrSkipHandles[0] = pSkip2->GetRefEHandle().GetEntryIndex();
+		m_arrSkipHandles[2] = pSkip2->GetOwnerHandleIndex();
+		m_arrCollisions[0] = pSkip2->GetCollisionMask();
+	}
+}

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/cgametracemanager.h

@@ -0,0 +1,118 @@
+#pragma once
+// used: pad and findpattern
+#include "../../utilities/memory.h"
+// used: vector
+#include "../../sdk/datatypes/vector.h"
+// used: array
+#include <array>
+
+struct Ray_t
+{
+public:
+	Vector_t m_vecStart;
+	Vector_t m_vecEnd;
+	Vector_t m_vecMins;
+	Vector_t m_vecMaxs;
+	MEM_PAD(0x4);
+	std::uint8_t UnkType;
+};
+static_assert(sizeof(Ray_t) == 0x38);
+
+struct SurfaceData_t
+{
+public:
+	MEM_PAD(0x8)
+	float m_flPenetrationModifier;
+	float m_flDamageModifier;
+	MEM_PAD(0x4)
+	int m_iMaterial;
+};
+
+static_assert(sizeof(SurfaceData_t) == 0x18);
+
+struct TraceHitboxData_t
+{
+public:
+	MEM_PAD(0x38);
+	int m_nHitGroup;
+	MEM_PAD(0x4);
+	int m_nHitboxId;
+};
+static_assert(sizeof(TraceHitboxData_t) == 0x44);
+
+class C_CSPlayerPawn;
+struct GameTrace_t
+{
+public:
+	GameTrace_t() = default;
+
+	SurfaceData_t* GetSurfaceData();
+	int GetHitboxId();
+	int GetHitgroup();
+	bool IsVisible() const;
+
+	void* m_pSurface;
+	C_CSPlayerPawn* m_pHitEntity;
+	TraceHitboxData_t* m_pHitboxData;
+	MEM_PAD(0x38);
+	std::uint32_t m_uContents;
+	MEM_PAD(0x24);
+	Vector_t m_vecStartPos;
+	Vector_t m_vecEndPos;
+	Vector_t m_vecNormal;
+	Vector_t m_vecPosition;
+	MEM_PAD(0x4);
+	float m_flFraction;
+	MEM_PAD(0x6);
+	bool m_bAllSolid;
+	MEM_PAD(0x4D)
+}; // Size: 0x108
+
+static_assert(sizeof(GameTrace_t) == 0x108);
+
+struct TraceFilter_t
+{
+public:
+	MEM_PAD(0x8);
+	std::int64_t m_uTraceMask;
+	std::array<std::int64_t, 2> m_v1;
+	std::array<std::int32_t, 4> m_arrSkipHandles;
+	std::array<std::int16_t, 2> m_arrCollisions;
+	std::int16_t m_v2;
+	std::uint8_t m_v3;
+	std::uint8_t m_v4;
+	std::uint8_t m_v5;
+
+	TraceFilter_t() = default;
+	TraceFilter_t(std::uint64_t uMask, C_CSPlayerPawn* pSkip1, C_CSPlayerPawn* pSkip2, int nLayer);
+};
+static_assert(sizeof(TraceFilter_t) == 0x40);
+
+class CGameTraceManager
+{
+public:
+	bool TraceShape(Ray_t* pRay, Vector_t vecStart, Vector_t vecEnd, TraceFilter_t* pFilter, GameTrace_t* pGameTrace)
+	{
+		using fnTraceShape = bool(__fastcall*)(CGameTraceManager*, Ray_t*, Vector_t*, Vector_t*, TraceFilter_t*, GameTrace_t*);
+		// Credit: https://www.unknowncheats.me/forum/4265752-post6333.html
+		static fnTraceShape oTraceShape = reinterpret_cast<fnTraceShape>(MEM::FindPattern(CLIENT_DLL, CS_XOR("48 89 5C 24 20 48 89 4C 24 08 55 56 41")));
+
+		#ifdef CS_PARANOID
+		CS_ASSERT(oTraceShape != nullptr);
+		#endif
+
+		return oTraceShape(this, pRay, &vecStart, &vecEnd, pFilter, pGameTrace);
+	}
+
+	bool ClipRayToEntity(Ray_t* pRay, Vector_t vecStart, Vector_t vecEnd, C_CSPlayerPawn* pPawn, TraceFilter_t* pFilter, GameTrace_t* pGameTrace)
+	{
+		using fnClipRayToEntity = bool(__fastcall*)(CGameTraceManager*, Ray_t*, Vector_t*, Vector_t*, C_CSPlayerPawn*, TraceFilter_t*, GameTrace_t*);
+		static fnClipRayToEntity oClipRayToEntity = reinterpret_cast<fnClipRayToEntity>(MEM::FindPattern(CLIENT_DLL, CS_XOR("48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 48 89 7C 24 20 41 54 41 56 41 57 48 81 EC C0 00 00 00 48 8B 9C")));
+
+		#ifdef CS_PARANOID
+		CS_ASSERT(oClipRayToEntity != nullptr);
+		#endif
+
+		return oClipRayToEntity(this, pRay, &vecStart, &vecEnd, pPawn, pFilter, pGameTrace);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/idebugoverlay.h

@@ -0,0 +1,15 @@
+#pragma once
+
+// used: find pattern, call virtual function
+#include "../../utilities/memory.h"
+
+// used: vertor_t
+#include "../datatypes/vector.h"
+// used: color_t
+#include "../datatypes/color.h"
+
+class IDebugOverlayGameSystem
+{
+public:
+	// @todo: reverse this
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/iengineclient.h

@@ -0,0 +1,67 @@
+#pragma once
+
+// used: callvfunc
+#include "../../utilities/memory.h"
+
+enum EClientFrameStage : int
+{
+	FRAME_UNDEFINED = -1,
+	FRAME_START,
+	// a network packet is being received
+	FRAME_NET_UPDATE_START,
+	// data has been received and we are going to start calling postdataupdate
+	FRAME_NET_UPDATE_POSTDATAUPDATE_START,
+	// data has been received and called postdataupdate on all data recipients
+	FRAME_NET_UPDATE_POSTDATAUPDATE_END,
+	// received all packets, we can now do interpolation, prediction, etc
+	FRAME_NET_UPDATE_END,
+	// start rendering the scene
+	FRAME_RENDER_START,
+	// finished rendering the scene
+	FRAME_RENDER_END,
+	FRAME_NET_FULL_FRAME_UPDATE_ON_REMOVE
+};
+
+class IEngineClient
+{
+public:
+	int GetMaxClients()
+	{
+		return MEM::CallVFunc<int, 34U>(this);
+	}
+
+	bool IsInGame()
+	{
+		return MEM::CallVFunc<bool, 35U>(this);
+	}
+
+	bool IsConnected()
+	{
+		return MEM::CallVFunc<bool, 36U>(this);
+	}
+
+	// return CBaseHandle index
+	int GetLocalPlayer()
+	{
+		int nIndex = -1;
+
+		MEM::CallVFunc<void, 47U>(this, std::ref(nIndex), 0);
+
+		return nIndex + 1;
+	}
+
+	[[nodiscard]] const char* GetLevelName()
+	{
+		return MEM::CallVFunc<const char*, 56U>(this);
+	}
+
+	[[nodiscard]] const char* GetLevelNameShort()
+	{
+		return MEM::CallVFunc<const char*, 57U>(this);
+	}
+
+	[[nodiscard]] const char* GetProductVersionString()
+	{
+		return MEM::CallVFunc<const char*, 82U>(this);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/ienginecvar.h

@@ -0,0 +1,150 @@
+#pragma once
+
+// used: cutllinkedlist
+#include "../datatypes/utllinkedlist.h"
+// used: fnv1a hashing
+#include "../../utilities/fnv1a.h"
+
+// used: sdk datatypes
+#include "../datatypes/color.h"
+#include "../datatypes/vector.h"
+#include "../datatypes/qangle.h"
+
+#pragma region convar_enumerations
+// command to convars and concommands
+enum EConVarFlag : int
+{
+	// convar systems
+	FCVAR_NONE = 0,
+	FCVAR_UNREGISTERED =			(1 << 0),	// if this is set, don't add to linked list, etc
+	FCVAR_DEVELOPMENTONLY =			(1 << 1),	// hidden in released products. flag is removed automatically if allow_development_cvars is defined
+	FCVAR_GAMEDLL =					(1 << 2),	// defined by the game dll
+	FCVAR_CLIENTDLL =				(1 << 3),	// defined by the client dll
+	FCVAR_HIDDEN =					(1 << 4),	// hidden. doesn't appear in find or autocomplete. like developmentonly, but can't be compiled out
+
+	// convar only
+	FCVAR_PROTECTED =				(1 << 5),	// it's a server cvar, but we don't send the data since it's a password, etc. sends 1 if it's not bland/zero, 0 otherwise as value
+	FCVAR_SPONLY =					(1 << 6),	// this cvar cannot be changed by clients connected to a multiplayer server
+	FCVAR_ARCHIVE =					(1 << 7),	// set to cause it to be saved to vars.rc
+	FCVAR_NOTIFY =					(1 << 8),	// notifies players when changed
+	FCVAR_USERINFO =				(1 << 9),	// changes the client's info string
+	FCVAR_CHEAT =					(1 << 14),	// only useable in singleplayer/debug/multiplayer & sv_cheats
+	FCVAR_PRINTABLEONLY =			(1 << 10),	// this cvar's string cannot contain unprintable characters (e.g., used for player name etc)
+	FCVAR_UNLOGGED =				(1 << 11),	// if this is a fcvar_server, don't log changes to the log file / console if we are creating a log
+	FCVAR_NEVER_AS_STRING =			(1 << 12),	// never try to print that cvar
+
+	// it's a convar that's shared between the client and the server.
+	// at signon, the values of all such convars are sent from the server to the client (skipped for local client, ofc)
+	// if a change is requested it must come from the console (i.e., no remote client changes)
+	// if a value is changed while a server is active, it's replicated to all connected clients
+	FCVAR_REPLICATED =				(1 << 13),	// server setting enforced on clients, replicated
+	// @todo: (1 << 14) used by the game, probably used as modification detection
+	FCVAR_DEMO =					(1 << 16),	// record this cvar when starting a demo file
+	FCVAR_DONTRECORD =				(1 << 17),	// don't record these command in demofiles
+	FCVAR_RELOAD_MATERIALS =		(1 << 20),	// if this cvar changes, it forces a material reload
+	FCVAR_RELOAD_TEXTURES =			(1 << 21),	// if this cvar changes, if forces a texture reload
+	FCVAR_NOT_CONNECTED =			(1 << 22),	// cvar cannot be changed by a client that is connected to a server
+	FCVAR_MATERIAL_SYSTEM_THREAD =	(1 << 23),	// indicates this cvar is read from the material system thread
+	FCVAR_ARCHIVE_XBOX =			(1 << 24),	// cvar written to config.cfg on the xbox
+	FCVAR_ACCESSIBLE_FROM_THREADS = (1 << 25),	// used as a debugging tool necessary to check material system thread convars
+	FCVAR_SERVER_CAN_EXECUTE =		(1 << 28),	// the server is allowed to execute this command on clients via clientcommand/net_stringcmd/cbaseclientstate::processstringcmd
+	FCVAR_SERVER_CANNOT_QUERY =		(1 << 29),	// if this is set, then the server is not allowed to query this cvar's value (via iserverpluginhelpers::startquerycvarvalue)
+	FCVAR_CLIENTCMD_CAN_EXECUTE =	(1 << 30),	// ivengineclient::clientcmd is allowed to execute this command
+	FCVAR_MATERIAL_THREAD_MASK =	(FCVAR_RELOAD_MATERIALS | FCVAR_RELOAD_TEXTURES | FCVAR_MATERIAL_SYSTEM_THREAD)
+};
+
+enum EConVarType : short
+{
+	EConVarType_Invalid = -1,
+	EConVarType_Bool,
+	EConVarType_Int16,
+	EConVarType_UInt16,
+	EConVarType_Int32,
+	EConVarType_UInt32,
+	EConVarType_Int64,
+	EConVarType_UInt64,
+	EConVarType_Float32,
+	EConVarType_Float64,
+	EConVarType_String,
+	EConVarType_Color,
+	EConVarType_Vector2,
+	EConVarType_Vector3,
+	EConVarType_Vector4,
+	EConVarType_Qangle,
+	EConVarType_MAX
+};
+
+#pragma endregion
+
+union CVValue_t
+{
+	bool i1;
+	short i16;
+	uint16_t u16;
+	int i32;
+	uint32_t u32;
+	int64_t i64;
+	uint64_t u64;
+	float fl;
+	double db;
+	const char* sz;
+	Color_t clr;
+	Vector2D_t vec2;
+	Vector_t vec3;
+	Vector4D_t vec4;
+	QAngle_t ang;
+};
+
+class CConVar
+{
+public:
+	const char* szName; // 0x0000
+	CConVar* m_pNext; // 0x0008
+	MEM_PAD(0x10); // 0x0010
+	const char* szDescription; // 0x0020
+	uint32_t nType; // 0x28
+	uint32_t nRegistered; // 0x2C
+	uint32_t nFlags; // 0x30
+	MEM_PAD(0x8); // 0x34
+	// @note: read-only, mofify with caution
+	CVValue_t value; // 0x40
+};
+
+class IEngineCVar
+{
+public:
+	MEM_PAD(0x40);
+	CUtlLinkedList<CConVar*> listConvars;
+
+	CConVar* Find(FNV1A_t uHashedName)
+	{
+		for (int i = I::Cvar->listConvars.Head(); i != I::Cvar->listConvars.InvalidIndex(); i = I::Cvar->listConvars.Next(i))
+		{
+			CConVar* pConVar = I::Cvar->listConvars.Element(i);
+			if (pConVar == nullptr)
+				continue;
+
+			if (FNV1A::Hash(pConVar->szName) == uHashedName)
+				return pConVar;
+		}
+
+		CS_ASSERT(false); // invalid convar name
+		return nullptr;
+	}
+
+	void UnlockHiddenCVars()
+	{
+		for (int i = I::Cvar->listConvars.Head(); i != I::Cvar->listConvars.InvalidIndex(); i = I::Cvar->listConvars.Next(i))
+		{
+			CConVar* pConVar = I::Cvar->listConvars.Element(i);
+			if (pConVar == nullptr)
+				continue;
+
+			if (pConVar->nFlags & FCVAR_HIDDEN)
+				pConVar->nFlags &= ~FCVAR_HIDDEN;
+
+			if (pConVar->nFlags & FCVAR_DEVELOPMENTONLY)
+				pConVar->nFlags &= ~FCVAR_DEVELOPMENTONLY;
+		}
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/igameresourceservice.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// used: mem_pad
+#include "../../utilities/memory.h"
+
+class CGameEntitySystem;
+
+class IGameResourceService
+{
+public:
+	MEM_PAD(0x58);
+	CGameEntitySystem* pGameEntitySystem;
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/iglobalvars.h

@@ -0,0 +1,20 @@
+#pragma once
+
+// used: mem_pad
+#include "../../utilities/memory.h"
+
+class IGlobalVars
+{
+public:
+	float flRealTime; //0x0000
+	int32_t nFrameCount; //0x0004
+	float flFrameTime; //0x0008
+	float flFrameTime2; //0x000C
+	int32_t nMaxClients; //0x0010
+	MEM_PAD(0x1C);
+	float flFrameTime3; //0x0030
+	float flCurrentTime; //0x0034
+	float flCurrentTime2; //0x0038
+	MEM_PAD(0xC);
+	int32_t nTickCount; //0x0048
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/iinputsystem.h

@@ -0,0 +1,20 @@
+#pragma once
+
+// used: getexportaddress
+#include "../../utilities/memory.h"
+
+class IInputSystem
+{
+public:
+	bool IsRelativeMouseMode()
+	{
+		// @ida: 'IInputSystem::SetRelativeMouseMode'.
+		return *reinterpret_cast<bool*>(reinterpret_cast<std::uintptr_t>(this) + 0x4D);
+	}
+
+	void* GetSDLWindow()
+	{
+		// @ida: IInputSystem::DebugSpew -> #STR: "Current coordinate bias %s: %g,%g scale %g,%g\n"
+		return *reinterpret_cast<void**>(reinterpret_cast<std::uintptr_t>(this) + 0x26A8);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/imaterialsystem.h

@@ -0,0 +1,126 @@
+#pragma once
+
+// used: call virtual function
+#include "../../utilities/memory.h"
+
+// used: color_t
+#include "../datatypes/color.h"
+// used: stronghandle
+#include "../datatypes/stronghandle.h"
+// used: keyvalue3
+#include "../datatypes/keyvalue3.h"
+// used vector4d_t
+#include "../datatypes/vector.h"
+
+// used: cbasehandle
+#include "../entity_handle.h"
+
+class CMaterial2
+{
+public:
+	virtual const char* GetName() = 0;
+	virtual const char* GetShareName() = 0;
+};
+
+// idk
+struct MaterialKeyVar_t
+{
+	std::uint64_t uKey;
+	const char* szName;
+
+	MaterialKeyVar_t(std::uint64_t uKey, const char* szName) :
+		uKey(uKey), szName(szName) { }
+
+	MaterialKeyVar_t(const char* szName, bool bShouldFindKey = false) :
+		szName(szName)
+	{
+		uKey = bShouldFindKey ? FindKey(szName) : 0x0;
+	}
+
+	std::uint64_t FindKey(const char* szName)
+	{
+		using fnFindKeyVar = std::uint64_t(CS_FASTCALL*)(const char*, unsigned int, int);
+		static auto oFindKeyVar = reinterpret_cast<fnFindKeyVar>(MEM::FindPattern(PARTICLES_DLL, CS_XOR("48 89 5C 24 ? 57 48 81 EC ? ? ? ? 33 C0 8B DA")));
+
+#ifdef CS_PARANOID
+		CS_ASSERT(oFindKeyVar != nullptr);
+#endif
+
+		// idk those enum flags, just saw it called like that soooo yea
+		return oFindKeyVar(szName, 0x12, 0x31415926);
+	}
+};
+
+class CObjectInfo
+{
+	MEM_PAD(0xB0);
+	int nId;
+};
+
+class CSceneAnimatableObject
+{
+	MEM_PAD(0xB8);
+	CBaseHandle hOwner;
+};
+
+// the naming is incorrect but i dont care atm
+class CMeshData
+{
+public:
+	void SetShaderType(const char* szShaderName)
+	{
+		// @ida: #STR: shader, spritecard.vfx
+		using fnSetMaterialShaderType = void(CS_FASTCALL*)(void*, MaterialKeyVar_t, const char*, int);
+		static auto oSetMaterialShaderType = reinterpret_cast<fnSetMaterialShaderType>(MEM::FindPattern(PARTICLES_DLL, CS_XOR("48 89 5C 24 ? 48 89 6C 24 ? 56 57 41 54 41 56 41 57 48 83 EC ? 0F B6 01 45 0F B6 F9 8B 2A 4D 8B E0 4C 8B 72 ? 48 8B F9 C0 E8 ? 24 ? 3C ? 74 ? 41 B0 ? B2 ? E8 ? ? ? ? 0F B6 07 33 DB C0 E8 ? 24 ? 3C ? 75 ? 48 8B 77 ? EB ? 48 8B F3 4C 8D 44 24 ? C7 44 24 ? ? ? ? ? 48 8D 54 24 ? 89 6C 24 ? 48 8B CE 4C 89 74 24 ? E8 ? ? ? ? 8B D0 83 F8 ? 75 ? 45 33 C9 89 6C 24 ? 4C 8D 44 24 ? 4C 89 74 24 ? 48 8B D7 48 8B CE E8 ? ? ? ? 8B D0 0F B6 0F C0 E9 ? 80 E1 ? 80 F9 ? 75 ? 48 8B 4F ? EB ? 48 8B CB 8B 41 ? 85 C0 74 ? 48 8D 59 ? 83 F8 ? 76 ? 48 8B 1B 48 63 C2 4D 85 E4")));
+
+		#ifdef CS_PARANOID
+		CS_ASSERT(oSetMaterialShaderType != nullptr);
+		#endif
+
+		MaterialKeyVar_t shaderVar(0x162C1777, CS_XOR("shader"));
+		oSetMaterialShaderType(this, shaderVar, szShaderName, 0x18);
+	}
+
+	void SetMaterialFunction(const char* szFunctionName, int nValue)
+	{
+		using fnSetMaterialFunction = void(__fastcall*)(void*, MaterialKeyVar_t, int, int);
+		static auto oSetMaterialFunction = reinterpret_cast<fnSetMaterialFunction>(MEM::FindPattern(PARTICLES_DLL, CS_XOR("48 89 5C 24 ? 48 89 6C 24 ? 56 57 41 54 41 56 41 57 48 83 EC ? 0F B6 01 45 0F B6 F9 8B 2A 48 8B F9")));
+
+		#ifdef CS_PARANOID
+		CS_ASSERT(oSetMaterialFunction != nullptr);
+		#endif
+
+		MaterialKeyVar_t functionVar(szFunctionName, true);
+		oSetMaterialFunction(this, functionVar, nValue, 0x18);
+	}
+
+	// Credit: https://www.unknowncheats.me/forum/4270816-post6392.html
+
+	MEM_PAD(0x18); // 0x0
+	CSceneAnimatableObject* pSceneAnimatableObject; // 0x18
+	CMaterial2* pMaterial; // 0x20
+	CMaterial2* pMaterialCpy; // 0x28
+	MEM_PAD(0x10);
+	CObjectInfo* pObjectInfo;
+	MEM_PAD(0x8);
+	Color_t colValue;
+};
+
+class IMaterialSystem2
+{
+public:
+	CMaterial2*** FindOrCreateFromResource(CMaterial2*** pOutMaterial, const char* szMaterialName)
+	{
+		return MEM::CallVFunc<CMaterial2***, 14U>(this, pOutMaterial, szMaterialName);
+	}
+
+	CMaterial2** CreateMaterial(CMaterial2*** pOutMaterial, const char* szMaterialName, CMeshData* pData)
+	{
+		return MEM::CallVFunc<CMaterial2**, 29U>(this, pOutMaterial, szMaterialName, pData, 0, 0, 0, 0, 0, 1);
+	}
+
+	void SetCreateDataByMaterial(const void* pData, CMaterial2*** const pInMaterial)
+	{
+		return MEM::CallVFunc<void, 37U>(this, pInMaterial, pData);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/imemalloc.h

@@ -0,0 +1,31 @@
+#pragma once
+// used: mem::CallVFunc
+#include "../../utilities/memory.h"
+#pragma warning(push)
+#pragma warning(disable : 4191)
+
+class IMemAlloc
+{
+public:
+	void* Alloc(std::size_t nSize)
+	{
+		return MEM::CallVFunc<void*, 1>(this, nSize);
+	}
+
+	void* ReAlloc(const void* pMemory, std::size_t nSize)
+	{
+		return MEM::CallVFunc<void*, 2>(this, pMemory, nSize);
+	}
+
+	void Free(const void* pMemory)
+	{
+		return MEM::CallVFunc<void, 3>(this, pMemory);
+	}
+
+	std::size_t GetSize(const void* pMemory)
+	{
+		return MEM::CallVFunc<std::size_t, 21>(this, pMemory);
+	}
+};
+
+#pragma warning(pop)

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/inetworkclientservice.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "../../utilities/memory.h"
+
+class CNetworkGameClient
+{
+public:
+	bool IsConnected()
+	{
+		return MEM::CallVFunc<bool, 12U>(this);
+	}
+
+	// force game to clear cache and reset delta tick
+	void FullUpdate()
+	{
+		// @ida: #STR: "Requesting full game update (%s)...\n"
+		MEM::CallVFunc<void, 28U>(this, CS_XOR("unk"));
+	}
+
+	int GetDeltaTick()
+	{
+		// @ida: offset in FullUpdate();
+		// (nDeltaTick = -1) == FullUpdate() called
+		return *reinterpret_cast<int*>(reinterpret_cast<std::uintptr_t>(this) + 0x25C);
+	}
+};
+
+class INetworkClientService
+{
+public:
+	[[nodiscard]] CNetworkGameClient* GetNetworkGameClient()
+	{
+		return MEM::CallVFunc<CNetworkGameClient*, 23U>(this);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/ipvs.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// used: MEM::CallVFunc
+#include "../../utilities/memory.h"
+
+class CPVS
+{
+public:
+	void Set(bool bState)
+	{
+		MEM::CallVFunc<void*, 7U>(this, bState);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/iresourcesystem.h

@@ -0,0 +1,24 @@
+#pragma once
+
+// used: callvfunc
+#include "../../utilities/memory.h"
+
+struct ResourceBinding_t;
+
+class IResourceSystem
+{
+public:
+	void* QueryInterface(const char* szInterfaceName)
+	{
+		return MEM::CallVFunc<void*, 2U>(this, szInterfaceName);
+	}
+};
+
+class CResourceHandleUtils
+{
+public:
+	void DeleteResource(const ResourceBinding_t* pBinding)
+	{
+		MEM::CallVFunc<void, 2U>(this, pBinding);
+	}
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/ischemasystem.h

@@ -0,0 +1,208 @@
+#pragma once
+
+// used: utlthash
+#include "../datatypes/utlthash.h"
+// used: utlvector
+#include "../datatypes/utlvector.h"
+// used: callvfunc
+#include "../../utilities/memory.h"
+
+#define SCHEMASYSTEM_TYPE_SCOPES_OFFSET 0x188
+#define SCHEMASYSTEMTYPESCOPE_OFF1 0x3F8
+#define SCHEMASYSTEMTYPESCOPE_OFF2 0x8
+
+using SchemaString_t = const char*;
+struct SchemaMetadataEntryData_t;
+
+class CSchemaSystemTypeScope;
+class CSchemaType;
+
+struct CSchemaClassBinding
+{
+	CSchemaClassBinding* pParent;
+	const char* szBinaryName; // ex: C_World
+	const char* szModuleName; // ex: libclient.so
+	const char* szClassName; // ex: client
+	void* pClassInfoOldSynthesized;
+	void* pClassInfo;
+	void* pThisModuleBindingPointer;
+	CSchemaType* pSchemaType;
+};
+
+class CSchemaType
+{
+public:
+	bool GetSizes(int* pOutSize, uint8_t* unkPtr)
+	{
+		return MEM::CallVFunc<bool, 3U>(this, pOutSize, unkPtr);
+	}
+
+public:
+	bool GetSize(int* out_size)
+	{
+		uint8_t smh = 0;
+		return GetSizes(out_size, &smh);
+	}
+
+public:
+	void* pVtable; // 0x0000
+	const char* szName; // 0x0008
+
+	CSchemaSystemTypeScope* pSystemTypeScope; // 0x0010
+	uint8_t nTypeCategory; // ETypeCategory 0x0018
+	uint8_t nAatomicCategory; // EAtomicCategory 0x0019
+};
+
+struct SchemaClassFieldData_t
+{
+	SchemaString_t szName; // 0x0000
+	CSchemaType* pSchemaType; // 0x0008
+	std::uint32_t nSingleInheritanceOffset; // 0x0010
+	std::int32_t nMetadataSize; // 0x0014
+	SchemaMetadataEntryData_t* pMetaData; // 0x0018
+};
+
+struct SchemaClassInfoData_t;
+
+struct SchemaBaseClassInfoData_t
+{
+	int32_t nOffset;
+	SchemaClassInfoData_t* pClass;
+};
+
+struct SchemaClassInfoData_t
+{
+private:
+	void* pVtable; // 0x0000
+public:
+	const char* szName; // 0x0008
+	char* szDescription; // 0x0010
+
+	int m_nSize; // 0x0018
+	std::int16_t nFieldSize; // 0x001C
+	std::int16_t nStaticSize; // 0x001E
+	std::int16_t nMetadataSize; // 0x0020
+
+	std::uint8_t nAlignOf; // 0x0022
+	std::uint8_t nBaseClassesCount; // 0x0023
+	char pad2[0x4]; // 0x0024
+	SchemaClassFieldData_t* pFields; // 0x0028
+	char pad3[0x8]; // 0x0030
+	SchemaBaseClassInfoData_t* pBaseClasses; // 0x0038
+	char pad4[0x28]; // 0x0040
+
+	//public:
+	//SchemaClassFieldData_t* pFields; // 0x0028
+
+	bool InheritsFrom(SchemaClassInfoData_t* pClassInfo)
+	{
+		if (pClassInfo == this && pClassInfo != nullptr)
+			return true;
+		else if (pBaseClasses == nullptr || pClassInfo == nullptr)
+			return false;
+
+		for (int i = 0; i < nBaseClassesCount; i++)
+		{
+			auto& baseClass = pBaseClasses[i];
+			if (baseClass.pClass->InheritsFrom(pClassInfo))
+				return true;
+		}
+
+		return false;
+	}
+};
+
+struct SchemaEnumeratorInfoData_t
+{
+	SchemaString_t szName;
+
+	union
+	{
+		unsigned char value_char;
+		unsigned short value_short;
+		unsigned int value_int;
+		unsigned long long value;
+	};
+
+	MEM_PAD(0x10); // 0x0010
+};
+
+class CSchemaEnumInfo
+{
+public:
+	SchemaEnumeratorInfoData_t enumInfoData;
+};
+
+class CSchemaEnumBinding
+{
+public:
+	virtual const char* GetBindingName() = 0;
+	virtual CSchemaClassBinding* AsClassBinding() = 0;
+	virtual CSchemaEnumBinding* AsEnumBinding() = 0;
+	virtual const char* GetBinaryName() = 0;
+	virtual const char* GetProjectName() = 0;
+
+public:
+	char* szBindingName_; // 0x0008
+	char* szDllName_; // 0x0010
+	std::int8_t nAlign_; // 0x0018
+	MEM_PAD(0x3); // 0x0019
+	std::int16_t nSize_; // 0x001C
+	std::int16_t nFlags_; // 0x001E
+	SchemaEnumeratorInfoData_t* pEnumInfo_;
+	MEM_PAD(0x8); // 0x0028
+	CSchemaSystemTypeScope* pTypeScope_; // 0x0030
+	MEM_PAD(0x8); // 0x0038
+	std::int32_t unk1_; // 0x0040
+};
+
+class CSchemaSystemTypeScope
+{
+public:
+	void FindDeclaredClass(SchemaClassInfoData_t** pReturnClass, const char* szClassName)
+	{
+		return MEM::CallVFunc<void, 2U>(this, pReturnClass, szClassName);
+	}
+
+	CSchemaType* FindSchemaTypeByName(const char* szName, std::uintptr_t* pSchema)
+	{
+		return MEM::CallVFunc<CSchemaType*, 4U>(this, szName, pSchema);
+	}
+
+	CSchemaType* FindTypeDeclaredClass(const char* szName)
+	{
+		return MEM::CallVFunc<CSchemaType*, 5U>(this, szName);
+	}
+
+	CSchemaType* FindTypeDeclaredEnum(const char* szName)
+	{
+		return MEM::CallVFunc<CSchemaType*, 6U>(this, szName);
+	}
+
+	CSchemaClassBinding* FindRawClassBinding(const char* szName)
+	{
+		return MEM::CallVFunc<CSchemaClassBinding*, 7U>(this, szName);
+	}
+
+	void* pVtable; // 0x0000
+	char szName[256U]; // 0x0008
+	MEM_PAD(SCHEMASYSTEMTYPESCOPE_OFF1); // 0x0108
+	CUtlTSHash<CSchemaClassBinding*, 256, unsigned int> hashClasses; // 0x0588
+	MEM_PAD(SCHEMASYSTEMTYPESCOPE_OFF2); // 0x05C8
+	CUtlTSHash<CSchemaEnumBinding*, 256, unsigned int> hashEnumes; // 0x2DD0
+};
+
+class ISchemaSystem
+{
+public:
+	CSchemaSystemTypeScope* FindTypeScopeForModule(const char* m_module_name)
+	{
+		return MEM::CallVFunc<CSchemaSystemTypeScope*, 13U>(this, m_module_name, nullptr);
+	}
+
+private:
+	MEM_PAD(SCHEMASYSTEM_TYPE_SCOPES_OFFSET); // 0x0000
+public:
+	// table of type scopes
+	CUtlVector<CSchemaSystemTypeScope*> vecTypeScopes; // SCHEMASYSTEM_TYPE_SCOPES_OFFSET
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/iswapchaindx11.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// used: call virtual function
+#include "../../utilities/memory.h"
+
+// forward declarations
+struct IDXGISwapChain;
+
+class ISwapChainDx11
+{
+	MEM_PAD(0x170);
+	IDXGISwapChain* pDXGISwapChain;
+};

examples/asphyxia-cs2-823331a79cf867972c517af8e94259fd479e09cf/cstrike/sdk/interfaces/iviewrender.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../datatypes/qangle.h"
+#include "../datatypes/matrix.h"
+
+class IViewRender
+{
+public:
+	Vector_t vecOrigin; // 0x0000
+	QAngle_t vecAngles; // 0x000C
+	float flFov; // 0x0018
+	char pad_0x001C[0x14]; // 0x001C
+	ViewMatrix_t matUNK1; // 0x0030
+	char pad_0x0070[0x30]; // 0x0070
+	ViewMatrix_t matUNK2; // 0x00A0
+	char pad_0x00E0[0xC8]; // 0x00E0
+	ViewMatrix_t matUNK3; // 0x01A8
+	char pad_0x01E8[0x28]; // 0x01E8
+};