├── .vs ├── slnx.sqlite ├── VSWorkspaceState.json └── CS2_Internal_Trainer │ ├── v17 │ ├── .suo │ └── Solution.VC.db │ └── FileContentIndex │ ├── 49b193c0-e551-4b87-89cf-cfcde274ab22.vsidx │ ├── 41709457-d394-4319-81b2-5163078f9a6e.vsidx │ ├── 5be0aba9-7cd3-44f6-b842-7df64fdac89e.vsidx │ ├── aee7357e-580a-4963-9d9e-bbdddef9a715.vsidx │ └── f7540576-bdba-4f78-83c0-082adfedb21f.vsidx ├── CS2_Internal_Trainer ├── SDK │ ├── Vector3.h │ ├── GameState.h │ ├── LocalPlayer.h │ ├── Vector3.cpp │ ├── GameState.cpp │ ├── CS2_Dumper │ │ ├── networksystem.dll.hpp │ │ ├── buttons.hpp │ │ ├── panorama.dll.hpp │ │ ├── offsets.hpp │ │ ├── scenesystem.dll.hpp │ │ ├── rendersystemdx11.dll.hpp │ │ ├── schemasystem.dll.hpp │ │ ├── materialsystem2.dll.hpp │ │ ├── interfaces.hpp │ │ ├── host.dll.hpp │ │ ├── engine2.dll.hpp │ │ ├── resourcesystem.dll.hpp │ │ └── worldrenderer.dll.hpp │ ├── MyPointers.h │ ├── LocalPlayer.cpp │ ├── Entity.h │ ├── MyPointers.cpp │ ├── PatternScan.h │ ├── MyOffsets.h │ ├── Entity.cpp │ ├── PatternScan.cpp │ └── Peb.h ├── Cheats │ ├── ESP │ │ ├── ESP.h │ │ ├── D3D11 │ │ │ ├── MyShaders.h │ │ │ ├── MyD3D_Utils.h │ │ │ ├── MyD3D_Utils.cpp │ │ │ ├── MyD3d11.h │ │ │ ├── MyD3d11_VMT.h │ │ │ └── MyD3d11.cpp │ │ └── ESP.cpp │ ├── CheatManager.h │ ├── Aimbot │ │ ├── Aimbot.h │ │ └── Aimbot.cpp │ └── CheatManager.cpp ├── Hook │ ├── TrampHook.h │ └── TrampHook.cpp ├── CS2_Internal_Trainer.vcxproj.user ├── Menu │ ├── ConsoleMenu.h │ └── ConsoleMenu.cpp ├── dllmain.cpp ├── CS2_Internal_Trainer.vcxproj.filters └── CS2_Internal_Trainer.vcxproj ├── CS2_Internal_Trainer.sln └── README.md /.vs/slnx.sqlite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/slnx.sqlite -------------------------------------------------------------------------------- /.vs/VSWorkspaceState.json: -------------------------------------------------------------------------------- 1 | { 2 | "ExpandedNodes": [ 3 | "" 4 | ], 5 | "PreviewInSolutionExplorer": false 6 | } -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/v17/.suo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/CS2_Internal_Trainer/v17/.suo -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/v17/Solution.VC.db: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/CS2_Internal_Trainer/v17/Solution.VC.db -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/FileContentIndex/49b193c0-e551-4b87-89cf-cfcde274ab22.vsidx: -------------------------------------------------------------------------------- 1 | CDGG '3 -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/FileContentIndex/41709457-d394-4319-81b2-5163078f9a6e.vsidx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/CS2_Internal_Trainer/FileContentIndex/41709457-d394-4319-81b2-5163078f9a6e.vsidx -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/FileContentIndex/5be0aba9-7cd3-44f6-b842-7df64fdac89e.vsidx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/CS2_Internal_Trainer/FileContentIndex/5be0aba9-7cd3-44f6-b842-7df64fdac89e.vsidx -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/FileContentIndex/aee7357e-580a-4963-9d9e-bbdddef9a715.vsidx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/CS2_Internal_Trainer/FileContentIndex/aee7357e-580a-4963-9d9e-bbdddef9a715.vsidx -------------------------------------------------------------------------------- /.vs/CS2_Internal_Trainer/FileContentIndex/f7540576-bdba-4f78-83c0-082adfedb21f.vsidx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kalvin-eliazord/Corty_Trainer/HEAD/.vs/CS2_Internal_Trainer/FileContentIndex/f7540576-bdba-4f78-83c0-082adfedb21f.vsidx -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/Vector3.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | struct Vector3 4 | { 5 | float x, y, z; 6 | 7 | Vector3 operator+(Vector3 d); 8 | Vector3 operator-(Vector3 d); 9 | Vector3 operator*(Vector3 d); 10 | Vector3 operator*(float d); 11 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/GameState.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "MyPointers.h" 4 | 5 | namespace GameState 6 | { 7 | enum GameStateId 8 | { 9 | NO_STATE, 10 | IN_LOBBY = 4, 11 | IN_GAME = 8 12 | }; 13 | 14 | inline bool bDefaultChange{ false }; 15 | bool IsDeathMatch(); 16 | bool IsMatchStarted(); 17 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/ESP.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MyD3D_Utils.h" 3 | #include "MyD3D11.h" 4 | #include "LocalPlayer.h" 5 | #include "Entity.h" 6 | #include "ConsoleMenu.h" 7 | #include "PatternScan.h" 8 | #include 9 | 10 | extern MyD3D11 g_myD3d11; 11 | 12 | namespace ESP 13 | { 14 | bool Start(const std::vector& pTargets); 15 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/LocalPlayer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MyPointers.h" 3 | #include "Entity.h" 4 | #include "Vector3.h" 5 | #include "Aimbot.h" 6 | 7 | namespace LocalPlayer 8 | { 9 | Pawn GetPawn(); 10 | Entity GetEntity(); 11 | Controller GetController(); 12 | Vector3* GetViewAnglesPtr(); 13 | bool SetViewAngles(const Vector3& targetAngle); 14 | bool SetSmoothViewAngles(Vector3 pTargetAngle, const int pSmoothValue); 15 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/CheatManager.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Aimbot.h" 3 | #include "ESP.h" 4 | #include "ConsoleMenu.h" 5 | #include "MyPointers.h" 6 | #include "GameState.h" 7 | #include "TrampHook.h" 8 | #include "MyD3D11.h" 9 | 10 | namespace CheatManager 11 | { 12 | std::vector GetValidTargets(); 13 | bool IsGoodTarget(Entity* pCurrEntPtr); 14 | inline const bool* bHookPtr{}; 15 | bool InitHook(); 16 | bool Run(); 17 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/Vector3.cpp: -------------------------------------------------------------------------------- 1 | #include "Vector3.h" 2 | 3 | Vector3 Vector3::operator+(Vector3 d) 4 | { 5 | return { x + d.x, y + d.y, z + d.z }; 6 | } 7 | 8 | Vector3 Vector3::operator-(Vector3 d) 9 | { 10 | return { x - d.x, y - d.y, z - d.z }; 11 | } 12 | 13 | Vector3 Vector3::operator*(Vector3 d) 14 | { 15 | return { x * d.x, y * d.y, z * d.z }; 16 | } 17 | 18 | Vector3 Vector3::operator*(float d) 19 | { 20 | return { x * d, y * d, z * d }; 21 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/GameState.cpp: -------------------------------------------------------------------------------- 1 | #include "GameState.h" 2 | 3 | bool GameState::IsDeathMatch() 4 | { 5 | const intptr_t* deathMatchPtr{ MyPointers::GetDeathMatchRulesPtr() }; 6 | return deathMatchPtr ? true : false; 7 | } 8 | 9 | bool GameState::IsMatchStarted() 10 | { 11 | const int matchStateId { *MyPointers::GetMatchStateIdPtr()}; 12 | 13 | switch (matchStateId) 14 | { 15 | case IN_GAME: return true; 16 | case IN_LOBBY: return false; 17 | case NO_STATE: return false; 18 | default: return false; 19 | } 20 | 21 | return false; 22 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/D3D11/MyShaders.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | constexpr const char* shaders = R"( 4 | // Constant buffer 5 | cbuffer ConstantBuffer : register(b0) 6 | { 7 | matrix projection; 8 | } 9 | 10 | // PSI (PixelShaderInput) 11 | struct PSI 12 | { 13 | float4 pos : SV_POSITION; 14 | float4 color : COLOR; 15 | }; 16 | 17 | // VertexShader 18 | PSI VS( float4 pos : POSITION, float4 color : COLOR ) 19 | { 20 | PSI psi; 21 | psi.pos = mul( projection, pos ); 22 | psi.color = color; 23 | return psi; 24 | } 25 | 26 | // PixelShader 27 | float4 PS(PSI psi) : SV_TARGET 28 | { 29 | return psi.color; 30 | } 31 | )"; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/networksystem.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace cs2_dumper { 9 | namespace schemas { 10 | // Module: networksystem.dll 11 | // Classes count: 1 12 | // Enums count: 0 13 | namespace networksystem_dll { 14 | // Parent: None 15 | // Fields count: 1 16 | namespace ChangeAccessorFieldPathIndex_t { 17 | constexpr std::ptrdiff_t m_Value = 0x0; // int16 18 | } 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Hook/TrampHook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | 5 | class TrampHook 6 | { 7 | private: 8 | const int jmpSize{ 14 }; 9 | bool bHooked{false}; 10 | 11 | intptr_t* srcAddr{}; 12 | intptr_t stolenBytes; 13 | 14 | intptr_t* dstAddr{}; 15 | intptr_t* gatewayAddr{}; 16 | 17 | bool InitGateway(intptr_t* pSrcAddr, intptr_t* pDstAddr, int pStolenBSize); 18 | bool HookSource(intptr_t* pSrcAddr, intptr_t* pDstAddr, int pStolenBSize); 19 | public: 20 | const intptr_t stolenBSize; 21 | 22 | TrampHook(intptr_t* pSrcAddr, intptr_t* pDstAddr, int pStolenBSize); 23 | TrampHook(int pStolenBSize); 24 | void Unhook(); 25 | const bool& GetbHookRef(); 26 | ~TrampHook(); 27 | intptr_t* GetGateway(); 28 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/Aimbot/Aimbot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MyPointers.h" 3 | #include "LocalPlayer.h" 4 | #include "Entity.h" 5 | #include "ConsoleMenu.h" 6 | #include 7 | #include 8 | 9 | namespace Aimbot 10 | { 11 | inline Entity cTargetLocked{}; 12 | 13 | Entity GetEntTarget(const std::vector& pTargets); 14 | std::vector GetValidTargets(); 15 | 16 | bool IsTargetInFov(Vector3& pTargetAngle); 17 | bool IsSpotted(Entity pCurrEnt); 18 | 19 | float GetMagnitude(const Vector3& pVec); 20 | Vector3 GetTargetAngle(Vector3 pTargetPos); 21 | Entity GetNearestTarget(std::vector pTargetsEnts); 22 | 23 | void NormalizeYaw(float& pYaw); 24 | void NormalizePitch(float& pPitch); 25 | 26 | bool Start(const std::vector& pTargets); 27 | bool ShotLockedTarget(); 28 | bool ShotTarget(const Entity& pCTarget); 29 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/D3D11/MyD3D_Utils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include "Vector3.h" 6 | 7 | namespace MyD3D_Utils 8 | { 9 | HWND FindMainWindow(DWORD dwPID); 10 | BOOL CALLBACK EnumWindowsCallback(HWND hWnd, LPARAM lParam); 11 | bool WorldToScreen(Vector3 pWorldPos, Vector3& pScreenPos, float* pMatrixPtr, const FLOAT pWinWidth, const FLOAT pWinHeight); 12 | 13 | inline constexpr D3DCOLORVALUE red{ 1.0f, 0.0f, 0.0f, 1.0f }; 14 | inline constexpr D3DCOLORVALUE green{ 0.0f, 1.0f, 0.0f, 1.0f }; 15 | inline constexpr D3DCOLORVALUE blue{ 0.0f, 0.0f, 1.0f, 1.0f }; 16 | inline constexpr D3DCOLORVALUE magenta{ 1.0f, 0.0f, 1.0f, 1.0f }; 17 | inline constexpr D3DCOLORVALUE yellow{ 1.0f, 1.0f, 0.0f, 1.0f }; 18 | } 19 | 20 | struct Vertex 21 | { 22 | DirectX::XMFLOAT3 pos; 23 | D3DCOLORVALUE color; 24 | }; 25 | 26 | struct WindowData 27 | { 28 | DWORD wndId; 29 | HWND hWnd; 30 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/MyPointers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include "MyOffsets.h" 5 | #include "Vector3.h" 6 | 7 | namespace MyPointers 8 | { 9 | float* GetViewMatrixPtr(); 10 | int* GetMatchStateIdPtr(); 11 | Vector3* GetViewAnglesPtr(); 12 | intptr_t GetPredictionBase(); 13 | intptr_t GetLpControllerBase(); 14 | intptr_t* GetDeathMatchRulesPtr(); 15 | intptr_t GetGameEntitySystemBase(); 16 | intptr_t GetEntityBase(intptr_t pIndex); 17 | 18 | template 19 | T ReadInternalMem(intptr_t pBaseAddr, std::vector pListOffset) 20 | { 21 | if ((!pBaseAddr || pListOffset.empty())) 22 | return T(); 23 | 24 | intptr_t addrBuffer{ pBaseAddr}; 25 | T addrResult{}; 26 | 27 | for (const auto& currOffset : pListOffset) 28 | { 29 | if (!currOffset) return T(); 30 | 31 | addrBuffer = *reinterpret_cast(addrBuffer + currOffset); 32 | addrResult = static_cast(addrBuffer); 33 | } 34 | 35 | return addrResult; 36 | } 37 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/CS2_Internal_Trainer.vcxproj.user: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | C:\Program Files %28x86%29\Steam\steamapps\common\Counter-Strike Global Offensive\game\bin\win64\cs2.exe 5 | true 6 | WindowsLocalDebugger 7 | 8 | 9 | C:\Program Files %28x86%29\Steam\steamapps\common\Counter-Strike Global Offensive\game\bin\win64\cs2.exe 10 | true 11 | WindowsLocalDebugger 12 | 13 | 14 | true 15 | 16 | -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Menu/ConsoleMenu.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "GameState.h" 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace ConsoleMenu 9 | { 10 | inline FILE* file{nullptr}; 11 | 12 | inline bool bTargetLock{ false }; 13 | inline bool bHeadPos{ true }; 14 | inline bool bAimbot{ false }; 15 | inline bool bESP{ true }; 16 | inline bool bTeamCheck{ true }; 17 | //inline bool bRCS{ true }; 18 | 19 | inline int smoothValue{ 0 }; 20 | inline int fovValue{ 25 }; 21 | 22 | inline bool bInitTeamCheck{ false }; 23 | bool IsOptionChanged(); 24 | bool SetDefaultTeamCheck(bool pIsDeathMatch); 25 | 26 | // Console info updates 27 | inline bool bLobbyStart{ true }; 28 | inline bool bInGameStart{ true }; 29 | inline bool bConsoleChanged{ true }; 30 | 31 | void InitConsole(); 32 | void PrintMyName(); 33 | void DestroyConsole(); 34 | void PrintCheatOptions(); 35 | std::string_view GetTargetedPart(); 36 | void PrintErrorPtrInit(const std::map & pAddresses); 37 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/buttons.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace cs2_dumper { 9 | // Module: client.dll 10 | namespace buttons { 11 | constexpr std::ptrdiff_t attack = 0x181C160; 12 | constexpr std::ptrdiff_t attack2 = 0x181C1F0; 13 | constexpr std::ptrdiff_t back = 0x181C430; 14 | constexpr std::ptrdiff_t duck = 0x181C700; 15 | constexpr std::ptrdiff_t forward = 0x181C3A0; 16 | constexpr std::ptrdiff_t jump = 0x181C670; 17 | constexpr std::ptrdiff_t left = 0x181C4C0; 18 | constexpr std::ptrdiff_t lookatweapon = 0x1A27D50; 19 | constexpr std::ptrdiff_t reload = 0x181C0D0; 20 | constexpr std::ptrdiff_t right = 0x181C550; 21 | constexpr std::ptrdiff_t showscores = 0x1A27C30; 22 | constexpr std::ptrdiff_t sprint = 0x181C040; 23 | constexpr std::ptrdiff_t turnleft = 0x181C280; 24 | constexpr std::ptrdiff_t turnright = 0x181C310; 25 | constexpr std::ptrdiff_t use = 0x181C5E0; 26 | constexpr std::ptrdiff_t zoom = 0x1A27CC0; 27 | } 28 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/ESP.cpp: -------------------------------------------------------------------------------- 1 | #include "ESP.h" 2 | 3 | bool ESP::Start(const std::vector& pTargets) 4 | { 5 | if (pTargets.empty()) return false; 6 | auto cTargets{pTargets }; 7 | 8 | const float winWidth{ g_myD3d11.m_viewport.Width }; 9 | const float winHeight{ g_myD3d11.m_viewport.Height }; 10 | 11 | for (auto& currTarget : cTargets) 12 | { 13 | Vector3 currBotPos{ currTarget.GetBonePos(Bone::ankle_L) }; 14 | Vector3 currTopPos{ currTarget.GetBonePos(Bone::head) }; 15 | 16 | Vector3 curr2DBot{}; 17 | Vector3 curr2DTop{}; 18 | 19 | if (!MyD3D_Utils::WorldToScreen(currBotPos, curr2DBot, MyPointers::GetViewMatrixPtr(), winWidth, winHeight)) 20 | continue; 21 | 22 | if (!MyD3D_Utils::WorldToScreen(currTopPos, curr2DTop, MyPointers::GetViewMatrixPtr(), winWidth, winHeight)) 23 | continue; 24 | 25 | // SnapLine 26 | g_myD3d11.DrawLine(curr2DBot.x, curr2DBot.y, winWidth / 2, winHeight, MyD3D_Utils::magenta); 27 | 28 | // Boxe 29 | const float height{ ::abs(curr2DTop.y - curr2DBot.y) * 1.25f }; 30 | const float width{ height / 2.f }; 31 | g_myD3d11.DrawBox(curr2DTop.x - (width / 2.f), curr2DTop.y - (width / 2.5f), width, height, MyD3D_Utils::magenta); 32 | } 33 | 34 | return true; 35 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/dllmain.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "CheatManager.h" 3 | #include "PatternScan.h" 4 | #include "ConsoleMenu.h" 5 | 6 | extern MyD3D11 g_myD3d11; 7 | 8 | DWORD WINAPI MainThread(HMODULE hModule) 9 | { 10 | PatternScan patternScan{}; 11 | 12 | if (!patternScan.InitPointers()) 13 | { 14 | ConsoleMenu::PrintErrorPtrInit(patternScan.GetPtrState()); 15 | while (!(GetAsyncKeyState(VK_DELETE) & 1)) Sleep(10); 16 | } 17 | else if (!CheatManager::InitHook()) 18 | { 19 | std::cerr << "[!] Hook failed. \n"; 20 | while (!(GetAsyncKeyState(VK_DELETE) & 1)) Sleep(10); 21 | } 22 | 23 | // Cleaning 24 | Sleep(500); 25 | ConsoleMenu::DestroyConsole(); 26 | VirtualFree(g_myD3d11.t_presentGateway, 0, MEM_RELEASE); 27 | FreeLibraryAndExitThread(hModule, 0); 28 | return 0; 29 | } 30 | 31 | BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) 32 | { 33 | HANDLE hMainThread{}; 34 | 35 | if (ul_reason_for_call == DLL_PROCESS_ATTACH) 36 | { 37 | DisableThreadLibraryCalls(hModule); 38 | hMainThread = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)&MainThread, hModule, 0, nullptr); 39 | } 40 | else if (ul_reason_for_call == DLL_PROCESS_DETACH) 41 | { 42 | if (hMainThread) CloseHandle(hMainThread); 43 | } 44 | 45 | return TRUE; 46 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/LocalPlayer.cpp: -------------------------------------------------------------------------------- 1 | #include "LocalPlayer.h" 2 | 3 | Entity LocalPlayer::GetEntity() 4 | { 5 | Entity lpEntityPtr(MyPointers::GetLpControllerBase(), 0); 6 | return lpEntityPtr; 7 | } 8 | 9 | Controller LocalPlayer::GetController() 10 | { 11 | return GetEntity().GetCBase(); 12 | } 13 | 14 | Pawn LocalPlayer::GetPawn() 15 | { 16 | return GetEntity().GetPawnBase(); 17 | } 18 | 19 | Vector3* LocalPlayer::GetViewAnglesPtr() 20 | { 21 | Vector3* viewAngles{ MyPointers::GetViewAnglesPtr() }; 22 | return viewAngles; 23 | } 24 | 25 | bool LocalPlayer::SetViewAngles(const Vector3& targetAngle) 26 | { 27 | Vector3* viewAnglesPtr{ MyPointers::GetViewAnglesPtr() }; 28 | 29 | if (!viewAnglesPtr) return false; 30 | 31 | viewAnglesPtr->x = targetAngle.x; 32 | viewAnglesPtr->y = targetAngle.y; 33 | 34 | return true; 35 | } 36 | 37 | bool LocalPlayer::SetSmoothViewAngles(Vector3 pTargetAngle, const int pSmoothValue) 38 | { 39 | Vector3* lpViewAngles{ MyPointers::GetViewAnglesPtr() }; 40 | 41 | Vector3 deltaAngle{ pTargetAngle - *lpViewAngles }; 42 | 43 | Aimbot::NormalizeYaw(deltaAngle.y); 44 | 45 | if (lpViewAngles->x != pTargetAngle.x) 46 | lpViewAngles->x += deltaAngle.x / pSmoothValue; 47 | 48 | if (lpViewAngles->y != pTargetAngle.y) 49 | lpViewAngles->y += deltaAngle.y / pSmoothValue; 50 | 51 | return true; 52 | } 53 | -------------------------------------------------------------------------------- /CS2_Internal_Trainer.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 17 4 | VisualStudioVersion = 17.7.34202.233 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CS2_Internal_Trainer", "CS2_Internal_Trainer\CS2_Internal_Trainer.vcxproj", "{9361A7BC-F8AF-420B-A79E-66E1AEFB153F}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Debug|x64.ActiveCfg = Debug|x64 17 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Debug|x64.Build.0 = Debug|x64 18 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Debug|x86.ActiveCfg = Debug|Win32 19 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Debug|x86.Build.0 = Debug|Win32 20 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Release|x64.ActiveCfg = Release|x64 21 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Release|x64.Build.0 = Release|x64 22 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Release|x86.ActiveCfg = Release|Win32 23 | {9361A7BC-F8AF-420B-A79E-66E1AEFB153F}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {7F01629D-A27E-4661-955E-987283CC1DEF} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/D3D11/MyD3D_Utils.cpp: -------------------------------------------------------------------------------- 1 | #include "MyD3D_Utils.h" 2 | 3 | HWND MyD3D_Utils::FindMainWindow(DWORD dwPID) 4 | { 5 | WindowData wndData{}; 6 | wndData.wndId = dwPID; 7 | EnumWindows(EnumWindowsCallback, (LPARAM)&wndData); 8 | 9 | return wndData.hWnd; 10 | } 11 | 12 | BOOL CALLBACK MyD3D_Utils::EnumWindowsCallback(HWND pHwnd, LPARAM lParam) 13 | { 14 | WindowData& wndData{ *(WindowData*)lParam }; 15 | DWORD currWndId{ 0 }; 16 | GetWindowThreadProcessId(pHwnd, &currWndId); 17 | 18 | if (currWndId == wndData.wndId && GetWindow(pHwnd, GW_OWNER) == HWND(0) && IsWindowVisible(pHwnd)) 19 | { 20 | wndData.hWnd = pHwnd; 21 | return FALSE; 22 | } 23 | 24 | return TRUE; 25 | } 26 | 27 | bool MyD3D_Utils::WorldToScreen(Vector3 pWorldPos, Vector3& pScreenPos, float* pMatrixPtr, const FLOAT pWinWidth, const FLOAT pWinHeight) 28 | { 29 | float matrix2[4][4]; 30 | 31 | memcpy(matrix2, pMatrixPtr, 16 * sizeof(float)); 32 | 33 | const float mX{ pWinWidth / 2 }; 34 | const float mY{ pWinHeight / 2 }; 35 | 36 | const float w { 37 | matrix2[3][0] * pWorldPos.x + 38 | matrix2[3][1] * pWorldPos.y + 39 | matrix2[3][2] * pWorldPos.z + 40 | matrix2[3][3] }; 41 | 42 | if (w < 0.65f) return false; 43 | 44 | const float x{ 45 | matrix2[0][0] * pWorldPos.x + 46 | matrix2[0][1] * pWorldPos.y + 47 | matrix2[0][2] * pWorldPos.z + 48 | matrix2[0][3] }; 49 | 50 | const float y { 51 | matrix2[1][0] * pWorldPos.x + 52 | matrix2[1][1] * pWorldPos.y + 53 | matrix2[1][2] * pWorldPos.z + 54 | matrix2[1][3] }; 55 | 56 | pScreenPos.x = (mX + mX * x / w); 57 | pScreenPos.y = (mY - mY * y / w); 58 | pScreenPos.z = 0; 59 | 60 | return true; 61 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/Entity.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MyOffsets.h" 3 | #include "MyPointers.h" 4 | #include "Vector3.h" 5 | #include 6 | #include 7 | 8 | enum Bone; 9 | struct BoneJoint; 10 | 11 | struct Controller 12 | { 13 | int32_t hPawn{}; 14 | std::string sEntName{}; 15 | }; 16 | 17 | struct Pawn 18 | { 19 | bool bDormant{}; 20 | int32_t iTeamNum{}; 21 | int32_t iHealth{}; 22 | Vector3 vLastCameraPos{}; 23 | Vector3 vAngEyeAngle{}; 24 | std::bitset<64> bSpottedMask{}; 25 | }; 26 | 27 | class Entity 28 | { 29 | private: 30 | bool isEntInit{ false }; 31 | intptr_t pawnBaseAddr{0}; 32 | intptr_t cBaseAddr{0}; 33 | int iIndex{}; 34 | 35 | Pawn pawnBase{}; 36 | Controller cBase{}; 37 | 38 | // Init Controller members 39 | bool SetHPawn(); 40 | bool SetPawnBase(); 41 | bool SetEntName(); 42 | bool UpdateController(); 43 | 44 | // Init Pawn members 45 | bool SetHealth(); 46 | bool SetSpottedMask(); 47 | bool SetIsDormant(); 48 | bool SetTeamNum(); 49 | bool SetvAngEyeAngle(); 50 | bool SetvLastCameraPos(); 51 | intptr_t GetBoneArrayBase(); 52 | bool UpdatePawn(); 53 | 54 | public: 55 | int GetIndex(); 56 | Pawn GetPawnBase(); 57 | Controller GetCBase(); 58 | Vector3 GetBonePos(Bone pBone); 59 | 60 | bool IsEntInit(); 61 | Entity(intptr_t pCBaseAddr, int pIndex); 62 | Entity(); 63 | }; 64 | 65 | struct BoneJoint 66 | { 67 | Vector3 pos{}; 68 | float scale; 69 | float rotation[4]; 70 | }; 71 | 72 | enum Bone 73 | { 74 | head = 6, 75 | neck_0 = 5, 76 | spine_1 = 4, 77 | spine_2 = 2, 78 | pelvis = 0, 79 | arm_upper_L = 8, 80 | arm_lower_L = 9, 81 | hand_L = 10, 82 | arm_upper_R = 13, 83 | arm_lower_R = 14, 84 | hand_R = 15, 85 | leg_upper_L = 22, 86 | leg_lower_L = 23, 87 | ankle_L = 24, 88 | leg_upper_R = 25, 89 | leg_lower_R = 26, 90 | ankle_R = 27, 91 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/panorama.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace cs2_dumper { 9 | namespace schemas { 10 | // Module: panorama.dll 11 | // Classes count: 0 12 | // Enums count: 2 13 | namespace panorama_dll { 14 | // Alignment: 4 15 | // Members count: 13 16 | enum class ELayoutNodeType : uint32_t { 17 | ROOT = 0x0, 18 | STYLES = 0x1, 19 | SCRIPT_BODY = 0x2, 20 | SCRIPTS = 0x3, 21 | SNIPPETS = 0x4, 22 | INCLUDE = 0x5, 23 | SNIPPET = 0x6, 24 | PANEL = 0x7, 25 | PANEL_ATTRIBUTE = 0x8, 26 | PANEL_ATTRIBUTE_VALUE = 0x9, 27 | REFERENCE_CONTENT = 0xA, 28 | REFERENCE_COMPILED = 0xB, 29 | REFERENCE_PASSTHROUGH = 0xC 30 | }; 31 | // Alignment: 4 32 | // Members count: 16 33 | enum class EStyleNodeType : uint32_t { 34 | ROOT = 0x0, 35 | EXPRESSION = 0x1, 36 | PROPERTY = 0x2, 37 | DEFINE = 0x3, 38 | IMPORT = 0x4, 39 | KEYFRAMES = 0x5, 40 | KEYFRAME_SELECTOR = 0x6, 41 | STYLE_SELECTOR = 0x7, 42 | WHITESPACE = 0x8, 43 | EXPRESSION_TEXT = 0x9, 44 | EXPRESSION_URL = 0xA, 45 | EXPRESSION_CONCAT = 0xB, 46 | REFERENCE_CONTENT = 0xC, 47 | REFERENCE_COMPILED = 0xD, 48 | REFERENCE_PASSTHROUGH = 0xE, 49 | COMPILER_CONDITIONAL = 0xF 50 | }; 51 | } 52 | } 53 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/MyPointers.cpp: -------------------------------------------------------------------------------- 1 | #include "MyPointers.h" 2 | 3 | intptr_t MyPointers::GetEntityBase(intptr_t pIndex) 4 | { 5 | const intptr_t entListBase{ static_cast(ReadInternalMem(MyOffset::GPointers::ClientMod, 6 | { MyOffset::GPointers::GameEntitySyst, MyOffset::EntityListPtr })) }; 7 | 8 | constexpr intptr_t entPadding{ 0x78 }; 9 | const intptr_t currEntIndex{ (pIndex + 1) * entPadding }; 10 | return static_cast(ReadInternalMem(entListBase, { currEntIndex })); 11 | } 12 | 13 | float* MyPointers::GetViewMatrixPtr() 14 | { 15 | return reinterpret_cast(MyOffset::GPointers::ClientMod + MyOffset::GPointers::ViewMatrix); 16 | } 17 | 18 | Vector3* MyPointers::GetViewAnglesPtr() 19 | { 20 | return reinterpret_cast(MyOffset::GPointers::ClientMod + MyOffset::GPointers::ViewAngles); 21 | } 22 | 23 | intptr_t MyPointers::GetPredictionBase() 24 | { 25 | return static_cast(ReadInternalMem(MyOffset::GPointers::ClientMod, { MyOffset::GPointers::Prediction })); 26 | } 27 | 28 | intptr_t MyPointers::GetLpControllerBase() 29 | { 30 | return static_cast(ReadInternalMem(MyOffset::GPointers::ClientMod, { MyOffset::GPointers::LP_Controller })); 31 | } 32 | 33 | int* MyPointers::GetMatchStateIdPtr() 34 | { 35 | return reinterpret_cast(MyPointers::GetPredictionBase() + MyOffset::IsMatchStarted); 36 | } 37 | 38 | intptr_t* MyPointers::GetDeathMatchRulesPtr() 39 | { 40 | const intptr_t deathMatchRulesPtr{ static_cast(ReadInternalMem(MyOffset::GPointers::ClientMod, 41 | { 42 | MyOffset::GPointers::GameRules, 43 | MyOffset::CS_GameRules::GameModeRules , 44 | MyOffset::CS_GameRules::DeathMatchPtr 45 | } 46 | )) }; 47 | 48 | return reinterpret_cast(deathMatchRulesPtr); 49 | } 50 | 51 | intptr_t MyPointers::GetGameEntitySystemBase() 52 | { 53 | return static_cast(ReadInternalMem(MyOffset::GPointers::ClientMod, { MyOffset::GPointers::GameEntitySyst })); 54 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/PatternScan.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "MyOffsets.h" 3 | #include "Vector3.h" 4 | #include "Peb.h" 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | class PatternScan 11 | { 12 | private: 13 | std::map pointersState; 14 | 15 | PEB* GetPEB(); 16 | LDR_DATA_TABLE_ENTRY* GetLdrEntry(const wchar_t* pModName); 17 | 18 | void SetViewAngles(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 19 | void SetPrediction(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 20 | void SetViewMatrix(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 21 | void SetGameRules(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 22 | void SetLpController(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 23 | void SetGameEntitySystem(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 24 | 25 | intptr_t GetPatternSize(const std::string& pPattern); 26 | std::vector GetParsedPattern(const std::string& pPattern); 27 | intptr_t GetPatternAddr(char* currRegion, intptr_t pRegionSize, const std::string& pPattern); 28 | intptr_t GetValidMemRegion(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern); 29 | intptr_t ExtractPointer(intptr_t pPatternResult); 30 | 31 | public: 32 | 33 | void SetClientMod(PVOID pDllBase); 34 | void SetEngine2Mod(PVOID pDllBase); 35 | 36 | bool InitPointers(); 37 | bool ArePointersInit(); 38 | std::map GetPtrState(); 39 | }; 40 | 41 | namespace Pattern 42 | { 43 | inline const std::string EntityList{ "48 8B 0D ?? ?? ?? ?? 48 89 7C 24 ?? 8B FA C1 EB" }; 44 | inline const std::string ViewMatrix{ "48 8D 0D ?? ?? ?? ?? 48 C1 E0 06" }; 45 | inline const std::string LP_Controller{ "48 8B ? ? ? ? ? 48 85 ? 74 ? B2 ? E8 ? ? ? ? 45 33" }; 46 | inline const std::string GameRules{ "48 8B ? ? ? ? ? 4C 8B ? 48 8B ? 48 8B ? FF 90 ? ? ? ? 0F B6" }; 47 | inline const std::string Prediction{ "48 8B ? ? ? ? ? B2 ? F3 0F ? ? ? ? 89 6C" }; 48 | inline const std::string CCSGoInput{ "4C 89 ? ? ? ? ? 0F 11 ? ? ? ? ? 48 89 ? ? ? ? ? 4C 89" }; // Dereference 2 times 49 | inline const std::string BoneMatrix{ "4D 8B ? ? ? ? ? 4D 8B ? ? ? ? ? 8B 9F" }; 50 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/MyOffsets.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "offsets.hpp" 4 | #include "client.dll.hpp" 5 | 6 | namespace MyOffset 7 | { 8 | inline constexpr intptr_t EntityListPtr{ 0x10 }; // GameEntitySystem + EntityListPtr 9 | inline constexpr intptr_t IsMatchStarted{ 0xA0 }; // Prediction + IsMatchStarted 10 | 11 | namespace GPointers 12 | { 13 | inline intptr_t ClientMod{}; 14 | inline intptr_t Engine2Mod{}; 15 | inline intptr_t GameRules{}; 16 | inline intptr_t CCSGO_Input{}; 17 | inline intptr_t LP_Controller{}; 18 | inline intptr_t ViewMatrix{}; 19 | inline intptr_t ViewAngles{}; 20 | inline intptr_t GameEntitySyst{}; 21 | inline intptr_t Prediction{}; 22 | } 23 | 24 | namespace Pawn 25 | { 26 | inline constexpr intptr_t BoneArray{ cs2_dumper::schemas::client_dll::CSkeletonInstance::m_modelState + 0x80 }; // GameSceneNode + BoneArray 27 | inline constexpr intptr_t iHealth{ cs2_dumper::schemas::client_dll::C_BaseEntity::m_iHealth }; 28 | inline constexpr intptr_t pGameSceneNode{ cs2_dumper::schemas::client_dll::C_BaseEntity::m_pGameSceneNode }; 29 | inline constexpr intptr_t iTeamNum{ cs2_dumper::schemas::client_dll::C_BaseEntity::m_iTeamNum }; 30 | inline constexpr intptr_t vLastClipCameraPos{ cs2_dumper::schemas::client_dll::C_CSPlayerPawnBase::m_vecLastClipCameraPos }; 31 | inline constexpr intptr_t vAngEyeAngles { cs2_dumper::schemas::client_dll::C_CSPlayerPawnBase::m_angEyeAngles }; 32 | inline constexpr intptr_t bSpottedMask{ cs2_dumper::schemas::client_dll::C_CSPlayerPawn::m_entitySpottedState + cs2_dumper::schemas::client_dll::EntitySpottedState_t::m_bSpottedByMask }; 33 | inline constexpr intptr_t bDormant{ cs2_dumper::schemas::client_dll::CGameSceneNode::m_bDormant }; // GameSceneNode + bDormant 34 | }; 35 | 36 | namespace Controller 37 | { 38 | inline constexpr intptr_t cEntName{ cs2_dumper::schemas::client_dll::CBasePlayerController::m_iszPlayerName }; 39 | inline constexpr intptr_t hPawn {cs2_dumper::schemas::client_dll::CCSPlayerController::m_hPlayerPawn }; 40 | }; 41 | 42 | namespace CCSGO_Input 43 | { 44 | inline constexpr intptr_t ViewAngles{ 0xB0 }; // CCSGOInput - ViewAngles 45 | } 46 | 47 | namespace CS_GameRules 48 | { 49 | inline constexpr intptr_t GameModeRules{ cs2_dumper::schemas::client_dll::C_CSGameRules::m_pGameModeRules }; 50 | inline constexpr intptr_t DeathMatchPtr{ 0x30 }; // GameRules + GameModeRules + DeathMatchPtr 51 | }; 52 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Corty Trainer 2 | Corty Trainer is an up to date dynamic-linked library **cheat** written in C++ for the CS2 game. 3 | 4 | ## Features 5 | - Aimbot 6 | - Smoothing 7 | - Target locking 8 | - FOV 9 | - Head or Pelvis focus 10 | - ESP 11 | - SnapLine 12 | - Boxe 13 | 14 | 15 | ## Preview 16 | ![V4](https://github.com/kalvin-eliazord/Corty_Trainer/assets/61147281/f543cbc1-d757-474f-b5a9-3463b86f0f0f) 17 | 18 | 19 | # FAQ 20 | - **What is an aimbot ?** 21 | 22 | This is a cheating functionality that will allow a player to aim at a target automatically. 23 | 24 | - **Why It's not working ?** 25 | 26 | If the console appears and there is no pointer error, please disable your antivirus and learn how to build the DLL file just below. 27 | 28 | - **Why "Corty" Trainer ?** 29 | 30 | This is my third name. 31 | 32 | ## How to build the DLL 33 | - Open the solution with MVS 2022 ![image](https://github.com/kalvin-eliazord/CS2_Internal_Trainer/assets/61147281/ea1e187b-f25d-4091-9f80-153009a8480c) 34 | - Go to configuration properties: 35 | - Select **Release** mode 36 | 37 | ![image](https://github.com/kalvin-eliazord/CS2_Internal_Trainer/assets/61147281/0ac42cd3-b228-4b82-abbe-7e47548c7196) 38 | 39 | - In "General">"C++ Language Standard": **C++20** 40 | 41 | ![image](https://github.com/kalvin-eliazord/CS2_Internal_Trainer/assets/61147281/be976f8d-2df4-4315-943c-5026ac094b13) 42 | 43 | - In "Linker">"Manifest File">"UAC Execution Level": **Admin level** 44 | 45 | ![image](https://github.com/kalvin-eliazord/CS2_Internal_Trainer/assets/61147281/df0ad3b7-f1eb-4f15-b820-74c2fe3f9636) 46 | 47 | - Click on the **right arrow** 48 | 49 | ![image](https://github.com/kalvin-eliazord/CS2_Internal_Trainer/assets/61147281/d633a6b0-ee4a-43ef-8d3b-fc03758a61b0) 50 | 51 | - Go to your solution directory, then **x64>Release>** you now have your own DLL 52 | ![image](https://github.com/kalvin-eliazord/CS2_Internal_Trainer/assets/61147281/96b7bdb6-6185-4edd-ad60-08161f43fb7c) 53 | 54 | 55 | ## To-do 56 | - Add ESP player names 57 | - Add RadarHack 58 | - Add ESP skeleton 59 | - Add Triggerbot 60 | - Add complete bone choice 61 | - Add No Recoil 62 | - Add a complete menu 63 | - No more hardcoded offset (full pattern scanning) 64 | 65 | ## Disclaimers 66 | ⚠️ This project is for learning purposes only and strictly prohibited for any illegal activities. Users bear full responsibility for any issues. ⚠️ -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/D3D11/MyD3d11.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #pragma comment(lib, "d3d11.lib") 8 | #pragma comment(lib, "d3dcompiler.lib") 9 | 10 | #include "MyD3D_Utils.h" 11 | #include "MyShaders.h" 12 | #include "MyD3D11_VMT.h" 13 | #include "Vector3.h" 14 | 15 | class MyD3D11 16 | { 17 | private: 18 | bool SetViewport(); 19 | bool CompileShaders(); 20 | bool SetConstantBuffer(); 21 | bool SetDeviceContextRenderTarget(); 22 | void SetOrthoMatrix(D3D11_VIEWPORT pViewport); 23 | bool SetInputLayout(ID3D10Blob* pCompiledShaderBlob); 24 | void SetInputAssembler(D3D_PRIMITIVE_TOPOLOGY pPrimitiveTopology); 25 | void SetLineVBuffer(float x, float y, float x2, float y2, D3DCOLORVALUE pColor); 26 | void SetLineWHVBuffer(float x, float y, float x2, float y2, D3DCOLORVALUE pColor); 27 | void SetBoxVBuffer(float pX, float pY, float pWidth, float pHeight, D3DCOLORVALUE pColor); 28 | bool CompileShader(const char* szShader, const char* szEntrypoint, const char* szTarget, ID3D10Blob** pBlob); 29 | 30 | public: 31 | ID3D11Device* m_device{ nullptr }; 32 | IDXGISwapChain* m_swapChain{ nullptr }; 33 | ID3D11DeviceContext* m_context{ nullptr }; 34 | bool bDrawInit{ false }; 35 | 36 | // Shaders 37 | ID3D11PixelShader* m_pixelShader{ nullptr }; 38 | ID3D11VertexShader* m_vertexShader{ nullptr }; 39 | 40 | // Input assembler 41 | ID3D11InputLayout* m_vInputLayout{ nullptr }; 42 | ID3D11Buffer* m_vertexBuffer{ nullptr }; 43 | ID3D11Buffer* m_constantBuffer{ nullptr }; 44 | DirectX::XMMATRIX m_orthoMatrix{}; 45 | 46 | // Rasterizer 47 | D3D11_VIEWPORT m_viewport{}; 48 | HWND m_hwnd{}; 49 | RECT m_hRect{}; 50 | 51 | // Output Merger 52 | ID3D11RenderTargetView* m_renderTargetView{ nullptr }; 53 | 54 | // Hooking 55 | using T_Present = HRESULT(*)(IDXGISwapChain* pSwap, UINT pSyncInterval, UINT pFlags); 56 | T_Present t_presentGateway{}; 57 | void* o_Present{}; 58 | bool SetO_Present(); 59 | 60 | // Setup graphic pipeline 61 | bool InitDraw(IDXGISwapChain* pSwapchain); 62 | HWND GetSwapHwnd(IDXGISwapChain* pSwapchain); 63 | 64 | // Drawing 65 | void TestRender(); 66 | void DrawLine(float x, float y, float x2, float y2, D3DCOLORVALUE color); 67 | void DrawBox(float x, float y, float width, float height, D3DCOLORVALUE color); 68 | void DrawLineWH(float x, float y, float width, float height, D3DCOLORVALUE color); 69 | 70 | void SafeRelease(auto*& pData); 71 | ~MyD3D11(); 72 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/CheatManager.cpp: -------------------------------------------------------------------------------- 1 | #include "CheatManager.h" 2 | 3 | MyD3D11 g_myD3d11{}; 4 | 5 | HRESULT hkPresent(IDXGISwapChain* pChain, UINT pSyncInterval, UINT pFlags) 6 | { 7 | if (CheatManager::bHookPtr) 8 | { 9 | if (!g_myD3d11.bDrawInit) 10 | g_myD3d11.bDrawInit = g_myD3d11.InitDraw(pChain); 11 | 12 | CheatManager::Run(); 13 | } 14 | 15 | return g_myD3d11.t_presentGateway(pChain, pSyncInterval, pFlags); 16 | } 17 | 18 | std::vector CheatManager::GetValidTargets() 19 | { 20 | std::vector cTargetsEntities{}; 21 | 22 | for (int i{ 0 }; i < 64; ++i) 23 | { 24 | Entity currEntity(MyPointers::GetEntityBase(i), i); 25 | 26 | if (!IsGoodTarget(&currEntity)) continue; 27 | 28 | cTargetsEntities.push_back(currEntity); 29 | } 30 | 31 | return cTargetsEntities; 32 | } 33 | 34 | bool CheatManager::IsGoodTarget(Entity* pCurrEntPtr) 35 | { 36 | if (!pCurrEntPtr->IsEntInit()) 37 | return false; 38 | 39 | if (!LocalPlayer::GetEntity().IsEntInit()) return false; 40 | Pawn lpPawn{ LocalPlayer::GetPawn() }; 41 | 42 | Pawn currEntPawn{ pCurrEntPtr->GetPawnBase() }; 43 | 44 | if (LocalPlayer::GetController().sEntName == pCurrEntPtr->GetCBase().sEntName) 45 | return false; 46 | 47 | if (currEntPawn.iHealth < 1) 48 | return false; 49 | 50 | if (currEntPawn.bDormant) 51 | return false; 52 | 53 | if (ConsoleMenu::bTeamCheck && lpPawn.iTeamNum == currEntPawn.iTeamNum) 54 | return false; 55 | 56 | return true; 57 | } 58 | 59 | bool CheatManager::InitHook() 60 | { 61 | ConsoleMenu::InitConsole(); 62 | 63 | // Get original Present address with the dummy device method 64 | if (!g_myD3d11.SetO_Present()) return false; 65 | 66 | // Hook original Present address 67 | TrampHook tHook( 68 | reinterpret_cast(g_myD3d11.o_Present), 69 | reinterpret_cast(hkPresent), 70 | 14); // Present stolen bytes size 71 | 72 | bHookPtr = &tHook.GetbHookRef(); 73 | if (!bHookPtr) return false; 74 | 75 | g_myD3d11.t_presentGateway = reinterpret_cast(tHook.GetGateway()); 76 | 77 | while (!(GetAsyncKeyState(VK_DELETE) & 1)) Sleep(10); 78 | 79 | return true; 80 | } 81 | 82 | bool CheatManager::Run() 83 | { 84 | if (!bHookPtr) return false; 85 | 86 | if (ConsoleMenu::IsOptionChanged()) 87 | ConsoleMenu::PrintCheatOptions(); 88 | 89 | if (GameState::IsMatchStarted()) 90 | { 91 | // Removing TeamCheck by default when in DeathMatch 92 | if(!ConsoleMenu::bInitTeamCheck && ConsoleMenu::SetDefaultTeamCheck(GameState::IsDeathMatch())) 93 | ConsoleMenu::PrintCheatOptions(); 94 | 95 | std::vector targets{ GetValidTargets()}; 96 | 97 | // Cheat Features 98 | if (ConsoleMenu::bAimbot) Aimbot::Start(targets); 99 | if (ConsoleMenu::bESP) ESP::Start(targets); 100 | } 101 | else 102 | { 103 | ConsoleMenu::bInitTeamCheck = false; 104 | //TODO: ESP->draw the box on myself 105 | } 106 | 107 | return true; 108 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/offsets.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace cs2_dumper { 9 | namespace offsets { 10 | // Module: client.dll 11 | namespace client_dll { 12 | constexpr std::ptrdiff_t dwCSGOInput = 0x1A27E30; 13 | constexpr std::ptrdiff_t dwEntityList = 0x19BDD78; 14 | constexpr std::ptrdiff_t dwGameEntitySystem = 0x1ADCBC8; 15 | constexpr std::ptrdiff_t dwGameEntitySystem_highestEntityIndex = 0x1510; 16 | constexpr std::ptrdiff_t dwGameRules = 0x1A1B668; 17 | constexpr std::ptrdiff_t dwGlobalVars = 0x1817638; 18 | constexpr std::ptrdiff_t dwGlowManager = 0x1A1AD50; 19 | constexpr std::ptrdiff_t dwLocalPlayerController = 0x1A0D9A8; 20 | constexpr std::ptrdiff_t dwLocalPlayerPawn = 0x1823A08; 21 | constexpr std::ptrdiff_t dwPlantedC4 = 0x1A251A8; 22 | constexpr std::ptrdiff_t dwPrediction = 0x18238C0; 23 | constexpr std::ptrdiff_t dwSensitivity = 0x1A1C338; 24 | constexpr std::ptrdiff_t dwSensitivity_sensitivity = 0x40; 25 | constexpr std::ptrdiff_t dwViewAngles = 0x1A2D248; 26 | constexpr std::ptrdiff_t dwViewMatrix = 0x1A1FCD0; 27 | constexpr std::ptrdiff_t dwViewRender = 0x1A20468; 28 | constexpr std::ptrdiff_t dwWeaponC4 = 0x19C1940; 29 | } 30 | // Module: engine2.dll 31 | namespace engine2_dll { 32 | constexpr std::ptrdiff_t dwBuildNumber = 0x52F834; 33 | constexpr std::ptrdiff_t dwNetworkGameClient = 0x52EBA0; 34 | constexpr std::ptrdiff_t dwNetworkGameClient_clientTickCount = 0x178; 35 | constexpr std::ptrdiff_t dwNetworkGameClient_deltaTick = 0x278; 36 | constexpr std::ptrdiff_t dwNetworkGameClient_isBackgroundMap = 0x281477; 37 | constexpr std::ptrdiff_t dwNetworkGameClient_localPlayer = 0xF0; 38 | constexpr std::ptrdiff_t dwNetworkGameClient_maxClients = 0x270; 39 | constexpr std::ptrdiff_t dwNetworkGameClient_serverTickCount = 0x174; 40 | constexpr std::ptrdiff_t dwNetworkGameClient_signOnState = 0x260; 41 | constexpr std::ptrdiff_t dwWindowHeight = 0x5F0424; 42 | constexpr std::ptrdiff_t dwWindowWidth = 0x5F0420; 43 | } 44 | // Module: inputsystem.dll 45 | namespace inputsystem_dll { 46 | constexpr std::ptrdiff_t dwInputSystem = 0x387F0; 47 | } 48 | // Module: matchmaking.dll 49 | namespace matchmaking_dll { 50 | constexpr std::ptrdiff_t dwGameTypes = 0x1A41C0; 51 | constexpr std::ptrdiff_t dwGameTypes_mapName = 0x120; 52 | } 53 | // Module: soundsystem.dll 54 | namespace soundsystem_dll { 55 | constexpr std::ptrdiff_t dwSoundSystem = 0x334E40; 56 | constexpr std::ptrdiff_t dwSoundSystem_engineViewData = 0x7C; 57 | } 58 | } 59 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Hook/TrampHook.cpp: -------------------------------------------------------------------------------- 1 | #include "TrampHook.h" 2 | 3 | TrampHook::TrampHook(intptr_t* pSrcAddr, intptr_t* pDstAddr, int pStolenBSize) 4 | : srcAddr{ pSrcAddr } 5 | , dstAddr{ pDstAddr } 6 | , stolenBSize{ pStolenBSize } 7 | { 8 | bHooked = InitGateway(pSrcAddr, pDstAddr, pStolenBSize); 9 | } 10 | 11 | TrampHook::TrampHook(int pStolenBSize) 12 | : stolenBSize{ pStolenBSize } 13 | { 14 | } 15 | 16 | bool TrampHook::InitGateway(intptr_t* pSrcAddr, intptr_t* pDstAddr, int pStolenBSize) 17 | { 18 | // Save source stolen bytes (for unhook later) 19 | DWORD oldSrcProtect{}; 20 | VirtualProtect(pSrcAddr, pStolenBSize, PAGE_EXECUTE_READWRITE, &oldSrcProtect); 21 | memcpy(&stolenBytes, pSrcAddr, pStolenBSize); 22 | 23 | // NOP original Steam Hook instruction 24 | memset(pSrcAddr, 0x90, 5); 25 | VirtualProtect(pSrcAddr, pStolenBSize, oldSrcProtect, &oldSrcProtect); 26 | 27 | // Alloc Gateway into the game memory 28 | gatewayAddr = static_cast(VirtualAlloc( 29 | NULL, 30 | pStolenBSize + jmpSize, 31 | MEM_COMMIT | MEM_RESERVE, 32 | PAGE_EXECUTE_READWRITE)); 33 | 34 | if (!gatewayAddr) return false; 35 | 36 | // Put stolen bytes into gateway 37 | memcpy(gatewayAddr, pSrcAddr, pStolenBSize); 38 | 39 | BYTE jmpSrc[14] 40 | { 41 | 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP QWORD PTR instruction 42 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 8 BYTES PTR to relative destination 43 | }; 44 | 45 | // Set JMP Relative Address 46 | const intptr_t srcJmpBackAddr{ reinterpret_cast(pSrcAddr) + jmpSize }; 47 | memcpy(jmpSrc + 6, &srcJmpBackAddr, 8); 48 | 49 | // Put JMP in gateway 50 | memcpy( 51 | reinterpret_cast(reinterpret_cast(gatewayAddr) + pStolenBSize) 52 | , &jmpSrc 53 | , jmpSize); 54 | 55 | return HookSource(pSrcAddr, pDstAddr, pStolenBSize); 56 | } 57 | 58 | bool TrampHook::HookSource(intptr_t* pSrcAddr, intptr_t* pDstAddr, int pStolenBSize) 59 | { 60 | DWORD oldProtect{}; 61 | VirtualProtect(pSrcAddr, pStolenBSize, PAGE_EXECUTE_READWRITE, &oldProtect); 62 | 63 | BYTE jmpDst[14] 64 | { 65 | 0xFF, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP QWORD PTR instruction 66 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 8 BYTES PTR to relative destination 67 | }; 68 | 69 | // Set JMP relative Addr to destination 70 | memcpy(jmpDst + 6, &pDstAddr, 8); 71 | 72 | // NOP stolen bytes 73 | memset(pSrcAddr, 0x90, pStolenBSize); 74 | 75 | // Put JMP in source 76 | memcpy(pSrcAddr, jmpDst, jmpSize); 77 | 78 | VirtualProtect(pSrcAddr, pStolenBSize, oldProtect, &oldProtect); 79 | 80 | return true; 81 | } 82 | 83 | const bool& TrampHook::GetbHookRef() 84 | { 85 | return bHooked; 86 | } 87 | 88 | intptr_t* TrampHook::GetGateway() 89 | { 90 | return gatewayAddr; 91 | } 92 | 93 | void TrampHook::Unhook() 94 | { 95 | if (bHooked) 96 | { 97 | bHooked = false; 98 | 99 | DWORD oldProtect{}; 100 | VirtualProtect(srcAddr, stolenBSize, PAGE_EXECUTE_READWRITE, &oldProtect); 101 | memcpy(srcAddr, &stolenBytes, stolenBSize); 102 | VirtualProtect(srcAddr, stolenBSize, oldProtect, &oldProtect); 103 | } 104 | } 105 | 106 | TrampHook::~TrampHook() 107 | { 108 | Unhook(); 109 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/D3D11/MyD3d11_VMT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | enum class IDXGISwapChainVMT { 4 | QueryInterface, 5 | AddRef, 6 | Release, 7 | SetPrivateData, 8 | SetPrivateDataInterface, 9 | GetPrivateData, 10 | GetParent, 11 | GetDevice, 12 | Present, 13 | GetBuffer, 14 | SetFullscreenState, 15 | GetFullscreenState, 16 | GetDesc, 17 | ResizeBuffers, 18 | ResizeTarget, 19 | GetContainingOutput, 20 | GetFrameStatistics, 21 | GetLastPresentCount, 22 | }; 23 | 24 | enum class ID3D11DeviceVMT { 25 | QueryInterface, 26 | AddRef, 27 | Release, 28 | CreateVideoDecoder, 29 | CreateVideoProcessor, 30 | CreateAuthenticatedChannel, 31 | CreateCryptoSession, 32 | CreateVideoDecoderOutputView, 33 | CreateVideoProcessorInputView, 34 | CreateVideoProcessorOutputView, 35 | CreateVideoProcessorEnumerator, 36 | GetVideoDecoderProfileCount, 37 | GetVideoDecoderProfile, 38 | CheckVideoDecoderFormat, 39 | GetVideoDecoderConfigCount, 40 | GetVideoDecoderConfig, 41 | GetContentProtectionCaps, 42 | CheckCryptoKeyExchange, 43 | SetPrivateData, 44 | SetPrivateDataInterface, 45 | }; 46 | 47 | enum class ID3D11DeviceContextVMT { 48 | QueryInterface, 49 | AddRef, 50 | Release, 51 | GetDevice, 52 | GetPrivateData, 53 | SetPrivateData, 54 | SetPrivateDataInterface, 55 | VSSetConstantBuffers, 56 | PSSetShaderResources, 57 | PSSetShader, 58 | PSSetSamplers, 59 | VSSetShader, 60 | DrawIndexed, 61 | Draw, 62 | Map, 63 | Unmap, 64 | PSSetConstantBuffers, 65 | IASetInputLayout, 66 | IASetVertexBuffers, 67 | IASetIndexBuffer, 68 | DrawIndexedInstanced, 69 | DrawInstanced, 70 | GSSetConstantBuffers, 71 | GSSetShader, 72 | IASetPrimitiveTopology, 73 | VSSetShaderResources, 74 | VSSetSamplers, 75 | Begin, 76 | End, 77 | GetData, 78 | SetPredication, 79 | GSSetShaderResources, 80 | GSSetSamplers, 81 | OMSetRenderTargets, 82 | OMSetRenderTargetsAndUnorderedAccessViews, 83 | OMSetBlendState, 84 | OMSetDepthStencilState, 85 | SOSetTargets, 86 | DrawAuto, 87 | DrawIndexedInstancedIndirect, 88 | DrawInstancedIndirect, 89 | Dispatch, 90 | DispatchIndirect, 91 | RSSetState, 92 | RSSetViewports, 93 | RSSetScissorRects, 94 | CopySubresourceRegion, 95 | CopyResource, 96 | UpdateSubresource, 97 | CopyStructureCount, 98 | ClearRenderTargetView, 99 | ClearUnorderedAccessViewUint, 100 | ClearUnorderedAccessViewFloat, 101 | ClearDepthStencilView, 102 | GenerateMips, 103 | SetResourceMinLOD, 104 | GetResourceMinLOD, 105 | ResolveSubresource, 106 | ExecuteCommandList, 107 | HSSetShaderResources, 108 | HSSetShader, 109 | HSSetSamplers, 110 | HSSetConstantBuffers, 111 | DSSetShaderResources, 112 | DSSetShader, 113 | DSSetSamplers, 114 | DSSetConstantBuffers, 115 | CSSetShaderResources, 116 | CSSetUnorderedAccessViews, 117 | CSSetShader, 118 | CSSetSamplers, 119 | CSSetConstantBuffers, 120 | VSGetConstantBuffers, 121 | PSGetShaderResources, 122 | PSGetShader, 123 | PSGetSamplers, 124 | VSGetShader, 125 | PSGetConstantBuffers, 126 | IAGetInputLayout, 127 | IAGetVertexBuffers, 128 | IAGetIndexBuffer, 129 | GSGetConstantBuffers, 130 | GSGetShader, 131 | IAGetPrimitiveTopology, 132 | VSGetShaderResources, 133 | VSGetSamplers, 134 | GetPredication, 135 | GSGetShaderResources, 136 | GSGetSamplers, 137 | OMGetRenderTargets, 138 | OMGetRenderTargetsAndUnorderedAccessViews, 139 | OMGetBlendState, 140 | OMGetDepthStencilState, 141 | SOGetTargets, 142 | RSGetState, 143 | RSGetViewports, 144 | RSGetScissorRects, 145 | HSGetShaderResources, 146 | HSGetShader, 147 | HSGetSamplers, 148 | HSGetConstantBuffers, 149 | DSGetShaderResources, 150 | DSGetShader, 151 | DSGetSamplers, 152 | DSGetConstantBuffers, 153 | CSGetShaderResources, 154 | CSGetUnorderedAccessViews, 155 | CSGetShader, 156 | CSGetSamplers, 157 | CSGetConstantBuffers, 158 | ClearState, 159 | Flush, 160 | GetType, 161 | GetContextFlags, 162 | FinishCommandList, 163 | }; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/Entity.cpp: -------------------------------------------------------------------------------- 1 | #include "Entity.h" 2 | 3 | Entity::Entity(intptr_t pCBaseAddr, int pIndex) 4 | : cBaseAddr{ pCBaseAddr } 5 | , iIndex{ pIndex } 6 | { 7 | if (cBaseAddr && UpdateController()) 8 | isEntInit = true; 9 | } 10 | 11 | Entity::Entity() 12 | {} 13 | 14 | bool Entity::UpdateController() 15 | { 16 | if (!SetEntName()) return false; 17 | if (!SetHPawn()) return false; 18 | if (!SetPawnBase()) return false; 19 | 20 | return true; 21 | } 22 | 23 | bool Entity::UpdatePawn() 24 | { 25 | if (!SetIsDormant()) return false; 26 | if (!SetHealth()) return false; 27 | if (!SetSpottedMask()) return false; 28 | if (!SetTeamNum()) return false; 29 | if (!SetvAngEyeAngle()) return false; 30 | if (!SetvLastCameraPos()) return false; 31 | 32 | return true; 33 | } 34 | 35 | bool Entity::SetHPawn() 36 | { 37 | cBase.hPawn = MyPointers::ReadInternalMem(cBaseAddr, { MyOffset::Controller::hPawn }); 38 | 39 | return cBase.hPawn ? true : false; 40 | } 41 | 42 | bool Entity::SetPawnBase() 43 | { 44 | const intptr_t cGameEntity{ MyPointers::GetGameEntitySystemBase() + MyOffset::EntityListPtr }; 45 | const int32_t pawnListOffset{ 8 * ((cBase.hPawn & 0x7FFF) >> 9) }; 46 | const int32_t pawnBaseOffset{ 0x78 * (cBase.hPawn & 0x1FF) }; 47 | 48 | intptr_t pawnBase{}; 49 | 50 | if (pawnListOffset) 51 | pawnBase = static_cast(MyPointers::ReadInternalMem(cGameEntity, { pawnListOffset, pawnBaseOffset })); 52 | else 53 | pawnBase = static_cast(MyPointers::ReadInternalMem(*reinterpret_cast(cGameEntity), { pawnBaseOffset })); 54 | 55 | if (!pawnBase) return false; 56 | pawnBaseAddr = pawnBase; 57 | 58 | if (!UpdatePawn()) return false; 59 | 60 | return true; 61 | } 62 | 63 | bool Entity::SetEntName() 64 | { 65 | const char* sEntNamePtr{ reinterpret_cast(cBaseAddr + MyOffset::Controller::cEntName) }; 66 | if (!sEntNamePtr) return false; 67 | 68 | const std::string entNameBuffer(sEntNamePtr); 69 | cBase.sEntName = entNameBuffer; 70 | 71 | return true; 72 | } 73 | 74 | bool Entity::SetIsDormant() 75 | { 76 | pawnBase.bDormant = MyPointers::ReadInternalMem(pawnBaseAddr, 77 | { MyOffset::Pawn::pGameSceneNode, MyOffset::Pawn::bDormant }); 78 | 79 | return true; 80 | } 81 | 82 | bool Entity::SetTeamNum() 83 | { 84 | pawnBase.iTeamNum = MyPointers::ReadInternalMem(pawnBaseAddr, { MyOffset::Pawn::iTeamNum }); 85 | return true; 86 | } 87 | 88 | bool Entity::SetvAngEyeAngle() 89 | { 90 | pawnBase.vAngEyeAngle = *reinterpret_cast(pawnBaseAddr + MyOffset::Pawn::vAngEyeAngles); 91 | return true; 92 | } 93 | 94 | bool Entity::SetvLastCameraPos() 95 | { 96 | pawnBase.vLastCameraPos = *reinterpret_cast(pawnBaseAddr + MyOffset::Pawn::vLastClipCameraPos); 97 | return true; 98 | } 99 | 100 | bool Entity::SetSpottedMask() 101 | { 102 | pawnBase.bSpottedMask = MyPointers::ReadInternalMem>(pawnBaseAddr, { MyOffset::Pawn::bSpottedMask }); 103 | return true; 104 | } 105 | 106 | bool Entity::SetHealth() 107 | { 108 | pawnBase.iHealth = MyPointers::ReadInternalMem(pawnBaseAddr, { MyOffset::Pawn::iHealth }); 109 | return true; 110 | } 111 | 112 | intptr_t Entity::GetBoneArrayBase() 113 | { 114 | return static_cast(MyPointers::ReadInternalMem(pawnBaseAddr, 115 | { MyOffset::Pawn::pGameSceneNode, MyOffset::Pawn::BoneArray })); 116 | } 117 | 118 | Vector3 Entity::GetBonePos(Bone pBone) 119 | { 120 | BoneJoint* boneJointBase{ reinterpret_cast(GetBoneArrayBase() + (pBone * sizeof(BoneJoint))) }; 121 | if (!boneJointBase) return Vector3(); 122 | 123 | return boneJointBase->pos; 124 | } 125 | 126 | Controller Entity::GetCBase() 127 | { 128 | return cBase; 129 | } 130 | 131 | int Entity::GetIndex() 132 | { 133 | return this->iIndex; 134 | } 135 | 136 | Pawn Entity::GetPawnBase() 137 | { 138 | return pawnBase; 139 | } 140 | 141 | bool Entity::IsEntInit() 142 | { 143 | return isEntInit; 144 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Menu/ConsoleMenu.cpp: -------------------------------------------------------------------------------- 1 | #include "ConsoleMenu.h" 2 | 3 | void ConsoleMenu::InitConsole() 4 | { 5 | AllocConsole(); 6 | freopen_s(&file, "CONOUT$", "w", stdout); 7 | 8 | ConsoleMenu::PrintCheatOptions(); 9 | } 10 | 11 | void ConsoleMenu::DestroyConsole() 12 | { 13 | if (file) 14 | fclose(file); 15 | 16 | FreeConsole(); 17 | } 18 | 19 | bool ConsoleMenu::IsOptionChanged() 20 | { 21 | if (GetAsyncKeyState(VK_F1) & 1) 22 | { 23 | ConsoleMenu::bHeadPos = !ConsoleMenu::bHeadPos; 24 | return true; 25 | } 26 | else if (GetAsyncKeyState(VK_F2) & 1) 27 | { 28 | ConsoleMenu::bTargetLock = !ConsoleMenu::bTargetLock; 29 | return true; 30 | } 31 | else if (GetAsyncKeyState(VK_F3) & 1 && 32 | ConsoleMenu::smoothValue > 0) 33 | { 34 | --ConsoleMenu::smoothValue; 35 | return true; 36 | } 37 | else if (GetAsyncKeyState(VK_F4)) 38 | { 39 | ++ConsoleMenu::smoothValue; 40 | return true; 41 | } 42 | else if (GetAsyncKeyState(VK_F5) & 1 && 43 | ConsoleMenu::fovValue > 10) 44 | { 45 | ConsoleMenu::fovValue -= 10; 46 | return true; 47 | } 48 | else if (GetAsyncKeyState(VK_F6) & 1 && 49 | ConsoleMenu::fovValue < 100) 50 | { 51 | ConsoleMenu::fovValue += 10; 52 | return true; 53 | } 54 | else if (GetAsyncKeyState(VK_F8) & 1) 55 | { 56 | ConsoleMenu::bESP = !ConsoleMenu::bESP; 57 | return true; 58 | } 59 | else if (GetAsyncKeyState(VK_F9) & 1) 60 | { 61 | ConsoleMenu::bAimbot = !(ConsoleMenu::bAimbot); 62 | return true; 63 | } 64 | else if (GetAsyncKeyState(VK_F10) & 1) 65 | { 66 | ConsoleMenu::bTeamCheck = !ConsoleMenu::bTeamCheck; 67 | return true; 68 | } 69 | 70 | return false; 71 | } 72 | 73 | bool ConsoleMenu::SetDefaultTeamCheck(bool pIsDeathMatch) 74 | { 75 | if (pIsDeathMatch) 76 | { 77 | ConsoleMenu::bTeamCheck = false; 78 | bInitTeamCheck = true; 79 | return true; 80 | } 81 | 82 | return false; 83 | } 84 | 85 | 86 | void ConsoleMenu::PrintMyName() 87 | { 88 | std::cout << R"( 89 | _____ _ _____ _ 90 | / __ \ | | |_ _| (_) 91 | | / \/ ___ _ __| |_ _ _ | |_ __ __ _ _ _ __ ___ _ __ 92 | | | / _ \| '__| __| | | | | | '__/ _` | | '_ \ / _ \ '__| 93 | | \__/\ (_) | | | |_| |_| | | | | | (_| | | | | | __/ | 94 | \____/\___/|_| \__|\__, | \_/_| \__,_|_|_| |_|\___|_| 95 | __/ | 96 | |___/ 97 | )" << '\n'; 98 | std::cout << "-------------------------------------------------------------- \n"; 99 | } 100 | 101 | void ConsoleMenu::PrintErrorPtrInit(const std::map & pPointers) 102 | { 103 | if (!file) 104 | InitConsole(); 105 | 106 | system("cls"); 107 | PrintMyName(); 108 | 109 | std::cout << "[+] >> PatternScan initialization error << \n"; 110 | 111 | for (const auto& pointer : pPointers) 112 | { 113 | if (!pointer.second) 114 | std::cout << "[!] "; 115 | else 116 | std::cout << "[+] "; 117 | 118 | std::cout << pointer.first << " = " << pointer.second << '\n'; 119 | } 120 | 121 | std::cout << "-------------------------------------------------------------- \n"; 122 | std::cout << "[+] --> press SUPPR to exit <-- \n"; 123 | } 124 | 125 | std::string_view ConsoleMenu::GetTargetedPart() 126 | { 127 | return ConsoleMenu::bHeadPos ? "HEAD" : "PELVIS"; 128 | } 129 | 130 | void ConsoleMenu::PrintCheatOptions() 131 | { 132 | system("cls"); 133 | PrintMyName(); 134 | std::cout << "[+] TARGETED PART : [F1] --> [[" << GetTargetedPart() << "]] \n"; 135 | std::cout << "[+] AIMBOT : [F9] " << std::boolalpha << "-->[[" << ConsoleMenu::bAimbot << "]] \n"; 136 | std::cout << "[+] ESP : [F8] " << std::boolalpha << "-->[[" << ConsoleMenu::bESP << "]] \n"; 137 | std::cout << "[+] TEAMCHECK : [F10] " << std::boolalpha << "-->[[" << ConsoleMenu::bTeamCheck << "]] \n"; 138 | std::cout << "-------------------------------------------------------------- \n"; 139 | std::cout << "[+] SMOOTH VALUE : [F3] (-) or F4 (+) " << "-->[[" << ConsoleMenu::smoothValue << "]] \n"; 140 | std::cout << "[+] FOV : [F5] (-) or F6 (+) " << "-->[[" << ConsoleMenu::fovValue << "]] \n"; 141 | std::cout << "[+] TARGET LOCKING : [F2] " << std::boolalpha << " -->[[" << ConsoleMenu::bTargetLock << "]] \n"; 142 | std::cout << "-------------------------------------------------------------- \n"; 143 | std::cout << "[+] --> [[ press SUPPR to exit] ] <-- \n"; 144 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/scenesystem.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: scenesystem.dll 12 | // Classes count: 9 13 | // Enums count: 1 14 | namespace scenesystem_dll { 15 | // Alignment: 1 16 | // Members count: 4 17 | enum class DisableShadows_t : uint8_t { 18 | kDisableShadows_None = 0x0, 19 | kDisableShadows_All = 0x1, 20 | kDisableShadows_Baked = 0x2, 21 | kDisableShadows_Realtime = 0x3 22 | }; 23 | // Parent: None 24 | // Fields count: 10 25 | // 26 | // Metadata: 27 | // MGetKV3ClassDefaults 28 | namespace CSSDSMsg_ViewTarget { 29 | constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString 30 | constexpr std::ptrdiff_t m_TextureId = 0x8; // uint64 31 | constexpr std::ptrdiff_t m_nWidth = 0x10; // int32 32 | constexpr std::ptrdiff_t m_nHeight = 0x14; // int32 33 | constexpr std::ptrdiff_t m_nRequestedWidth = 0x18; // int32 34 | constexpr std::ptrdiff_t m_nRequestedHeight = 0x1C; // int32 35 | constexpr std::ptrdiff_t m_nNumMipLevels = 0x20; // int32 36 | constexpr std::ptrdiff_t m_nDepth = 0x24; // int32 37 | constexpr std::ptrdiff_t m_nMultisampleNumSamples = 0x28; // int32 38 | constexpr std::ptrdiff_t m_nFormat = 0x2C; // int32 39 | } 40 | // Parent: None 41 | // Fields count: 2 42 | // 43 | // Metadata: 44 | // MGetKV3ClassDefaults 45 | namespace SceneViewId_t { 46 | constexpr std::ptrdiff_t m_nViewId = 0x0; // uint64 47 | constexpr std::ptrdiff_t m_nFrameCount = 0x8; // uint64 48 | } 49 | // Parent: None 50 | // Fields count: 2 51 | // 52 | // Metadata: 53 | // MGetKV3ClassDefaults 54 | namespace CSSDSEndFrameViewInfo { 55 | constexpr std::ptrdiff_t m_nViewId = 0x0; // uint64 56 | constexpr std::ptrdiff_t m_ViewName = 0x8; // CUtlString 57 | } 58 | // Parent: CSSDSMsg_LayerBase 59 | // Fields count: 0 60 | // 61 | // Metadata: 62 | // MGetKV3ClassDefaults 63 | namespace CSSDSMsg_PostLayer { 64 | } 65 | // Parent: None 66 | // Fields count: 6 67 | // 68 | // Metadata: 69 | // MGetKV3ClassDefaults 70 | namespace CSSDSMsg_LayerBase { 71 | constexpr std::ptrdiff_t m_viewId = 0x0; // SceneViewId_t 72 | constexpr std::ptrdiff_t m_ViewName = 0x10; // CUtlString 73 | constexpr std::ptrdiff_t m_nLayerIndex = 0x18; // int32 74 | constexpr std::ptrdiff_t m_nLayerId = 0x20; // uint64 75 | constexpr std::ptrdiff_t m_LayerName = 0x28; // CUtlString 76 | constexpr std::ptrdiff_t m_displayText = 0x30; // CUtlString 77 | } 78 | // Parent: CSSDSMsg_LayerBase 79 | // Fields count: 0 80 | // 81 | // Metadata: 82 | // MGetKV3ClassDefaults 83 | namespace CSSDSMsg_PreLayer { 84 | } 85 | // Parent: None 86 | // Fields count: 3 87 | // 88 | // Metadata: 89 | // MGetKV3ClassDefaults 90 | namespace CSSDSMsg_ViewTargetList { 91 | constexpr std::ptrdiff_t m_viewId = 0x0; // SceneViewId_t 92 | constexpr std::ptrdiff_t m_ViewName = 0x10; // CUtlString 93 | constexpr std::ptrdiff_t m_Targets = 0x18; // CUtlVector 94 | } 95 | // Parent: None 96 | // Fields count: 2 97 | // 98 | // Metadata: 99 | // MGetKV3ClassDefaults 100 | namespace CSSDSMsg_ViewRender { 101 | constexpr std::ptrdiff_t m_viewId = 0x0; // SceneViewId_t 102 | constexpr std::ptrdiff_t m_ViewName = 0x10; // CUtlString 103 | } 104 | // Parent: None 105 | // Fields count: 1 106 | // 107 | // Metadata: 108 | // MGetKV3ClassDefaults 109 | namespace CSSDSMsg_EndFrame { 110 | constexpr std::ptrdiff_t m_Views = 0x0; // CUtlVector 111 | } 112 | } 113 | } 114 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/rendersystemdx11.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: rendersystemdx11.dll 12 | // Classes count: 3 13 | // Enums count: 5 14 | namespace rendersystemdx11_dll { 15 | // Alignment: 4 16 | // Members count: 13 17 | enum class RenderPrimitiveType_t : uint32_t { 18 | RENDER_PRIM_POINTS = 0x0, 19 | RENDER_PRIM_LINES = 0x1, 20 | RENDER_PRIM_LINES_WITH_ADJACENCY = 0x2, 21 | RENDER_PRIM_LINE_STRIP = 0x3, 22 | RENDER_PRIM_LINE_STRIP_WITH_ADJACENCY = 0x4, 23 | RENDER_PRIM_TRIANGLES = 0x5, 24 | RENDER_PRIM_TRIANGLES_WITH_ADJACENCY = 0x6, 25 | RENDER_PRIM_TRIANGLE_STRIP = 0x7, 26 | RENDER_PRIM_TRIANGLE_STRIP_WITH_ADJACENCY = 0x8, 27 | RENDER_PRIM_INSTANCED_QUADS = 0x9, 28 | RENDER_PRIM_HETEROGENOUS = 0xA, 29 | RENDER_PRIM_COMPUTE_SHADER = 0xB, 30 | RENDER_PRIM_TYPE_COUNT = 0xC 31 | }; 32 | // Alignment: 4 33 | // Members count: 13 34 | enum class RenderBufferFlags_t : uint32_t { 35 | RENDER_BUFFER_USAGE_VERTEX_BUFFER = 0x1, 36 | RENDER_BUFFER_USAGE_INDEX_BUFFER = 0x2, 37 | RENDER_BUFFER_USAGE_SHADER_RESOURCE = 0x4, 38 | RENDER_BUFFER_USAGE_UNORDERED_ACCESS = 0x8, 39 | RENDER_BUFFER_BYTEADDRESS_BUFFER = 0x10, 40 | RENDER_BUFFER_STRUCTURED_BUFFER = 0x20, 41 | RENDER_BUFFER_APPEND_CONSUME_BUFFER = 0x40, 42 | RENDER_BUFFER_UAV_COUNTER = 0x80, 43 | RENDER_BUFFER_UAV_DRAW_INDIRECT_ARGS = 0x100, 44 | RENDER_BUFFER_ACCELERATION_STRUCTURE = 0x200, 45 | RENDER_BUFFER_SHADER_BINDING_TABLE = 0x400, 46 | RENDER_BUFFER_PER_FRAME_WRITE_ONCE = 0x800, 47 | RENDER_BUFFER_POOL_ALLOCATED = 0x1000 48 | }; 49 | // Alignment: 1 50 | // Members count: 8 51 | enum class RenderMultisampleType_t : uint8_t { 52 | RENDER_MULTISAMPLE_INVALID = 0xFFFFFFFFFFFFFFFF, 53 | RENDER_MULTISAMPLE_NONE = 0x0, 54 | RENDER_MULTISAMPLE_2X = 0x1, 55 | RENDER_MULTISAMPLE_4X = 0x2, 56 | RENDER_MULTISAMPLE_6X = 0x3, 57 | RENDER_MULTISAMPLE_8X = 0x4, 58 | RENDER_MULTISAMPLE_16X = 0x5, 59 | RENDER_MULTISAMPLE_TYPE_COUNT = 0x6 60 | }; 61 | // Alignment: 4 62 | // Members count: 4 63 | enum class InputLayoutVariation_t : uint32_t { 64 | INPUT_LAYOUT_VARIATION_DEFAULT = 0x0, 65 | INPUT_LAYOUT_VARIATION_STREAM1_INSTANCEID = 0x1, 66 | INPUT_LAYOUT_VARIATION_STREAM1_INSTANCEID_MORPH_VERT_ID = 0x2, 67 | INPUT_LAYOUT_VARIATION_MAX = 0x3 68 | }; 69 | // Alignment: 4 70 | // Members count: 3 71 | enum class RenderSlotType_t : uint32_t { 72 | RENDER_SLOT_INVALID = 0xFFFFFFFFFFFFFFFF, 73 | RENDER_SLOT_PER_VERTEX = 0x0, 74 | RENDER_SLOT_PER_INSTANCE = 0x1 75 | }; 76 | // Parent: None 77 | // Fields count: 4 78 | namespace VsInputSignatureElement_t { 79 | constexpr std::ptrdiff_t m_pName = 0x0; // char[64] 80 | constexpr std::ptrdiff_t m_pSemantic = 0x40; // char[64] 81 | constexpr std::ptrdiff_t m_pD3DSemanticName = 0x80; // char[64] 82 | constexpr std::ptrdiff_t m_nD3DSemanticIndex = 0xC0; // int32 83 | } 84 | // Parent: None 85 | // Fields count: 1 86 | namespace VsInputSignature_t { 87 | constexpr std::ptrdiff_t m_elems = 0x0; // CUtlVector 88 | } 89 | // Parent: None 90 | // Fields count: 7 91 | namespace RenderInputLayoutField_t { 92 | constexpr std::ptrdiff_t m_pSemanticName = 0x0; // uint8[32] 93 | constexpr std::ptrdiff_t m_nSemanticIndex = 0x20; // int32 94 | constexpr std::ptrdiff_t m_Format = 0x24; // uint32 95 | constexpr std::ptrdiff_t m_nOffset = 0x28; // int32 96 | constexpr std::ptrdiff_t m_nSlot = 0x2C; // int32 97 | constexpr std::ptrdiff_t m_nSlotType = 0x30; // RenderSlotType_t 98 | constexpr std::ptrdiff_t m_nInstanceStepRate = 0x34; // int32 99 | } 100 | } 101 | } 102 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/Aimbot/Aimbot.cpp: -------------------------------------------------------------------------------- 1 | #include "Aimbot.h" 2 | 3 | bool Aimbot::IsTargetInFov(Vector3& pTargetAngle) 4 | { 5 | Vector3 localPlayerAngle{ LocalPlayer::GetPawn().vAngEyeAngle }; 6 | Vector3 deltaAngle{ localPlayerAngle - pTargetAngle }; 7 | NormalizeYaw(deltaAngle.y); 8 | 9 | const float distFromCursor{ GetMagnitude(deltaAngle) }; 10 | 11 | // Checking if target is in FOV 12 | if (distFromCursor < ConsoleMenu::fovValue) 13 | return true; 14 | 15 | return false; 16 | } 17 | 18 | bool Aimbot::IsSpotted(Entity pCurrEnt) 19 | { 20 | Entity localPlayerEnt{ LocalPlayer::GetEntity()}; 21 | std::bitset<64> lpSpottedId{ localPlayerEnt.GetPawnBase().bSpottedMask }; 22 | std::bitset<64> currEntSpottedId{ pCurrEnt.GetPawnBase().bSpottedMask }; 23 | 24 | // Not spotted by entity AND entity not spotted me 25 | if (!(lpSpottedId.test(pCurrEnt.GetIndex()) || currEntSpottedId.test(localPlayerEnt.GetIndex()))) 26 | return false; 27 | 28 | return true; 29 | } 30 | 31 | Entity Aimbot::GetNearestTarget(std::vector pTargetsEnt) 32 | { 33 | float oldCoef{ FLT_MAX }; 34 | Entity nearestTarget{}; 35 | 36 | Pawn lpPawn{ LocalPlayer::GetPawn() }; 37 | 38 | for (const auto& currCTarget : pTargetsEnt) 39 | { 40 | Entity currEnt(currCTarget); 41 | 42 | // Get angle distance 43 | const Vector3 currTargetAngle{ GetTargetAngle(currEnt.GetPawnBase().vLastCameraPos) }; 44 | const Vector3 deltaAngle{ lpPawn.vAngEyeAngle - currTargetAngle }; 45 | const float angleDistance{ GetMagnitude(deltaAngle) }; 46 | 47 | // Get body position distance 48 | const Vector3 deltaPosition{ lpPawn.vLastCameraPos - currEnt.GetPawnBase().vLastCameraPos }; 49 | const float bodyPosDist{ GetMagnitude(deltaPosition) }; 50 | 51 | const float currDistCoef{ angleDistance * 0.8f + bodyPosDist * 0.2f }; 52 | 53 | if (oldCoef > currDistCoef) 54 | { 55 | oldCoef = currDistCoef; 56 | nearestTarget = currEnt; 57 | } 58 | } 59 | 60 | return nearestTarget; 61 | } 62 | 63 | Entity Aimbot::GetEntTarget(const std::vector& pTargets) 64 | { 65 | Entity target{}; 66 | 67 | if (pTargets.size() > 1) 68 | target = GetNearestTarget(pTargets); 69 | else 70 | target = pTargets[0]; 71 | 72 | if (IsSpotted(target)) return target; 73 | 74 | return Entity(); 75 | } 76 | 77 | void Aimbot::NormalizePitch(float& pPitch) 78 | { 79 | pPitch = (pPitch < -89.0f) ? -89.0f : pPitch; 80 | 81 | pPitch = (pPitch > 89.f) ? 89.0f : pPitch; 82 | } 83 | 84 | void Aimbot::NormalizeYaw(float& pYaw) 85 | { 86 | while (pYaw > 180.f) pYaw -= 360.f; 87 | 88 | while (pYaw < -180.f) pYaw += 360.f; 89 | } 90 | 91 | float Aimbot::GetMagnitude(const Vector3& pVec) 92 | { 93 | return ::sqrtf((pVec.x * pVec.x) + 94 | (pVec.y * pVec.y) + 95 | (pVec.z * pVec.z)); 96 | } 97 | Vector3 Aimbot::GetTargetAngle(Vector3 pTargetPos) 98 | { 99 | Vector3 targetAngle{}; 100 | Vector3 lpPos{ LocalPlayer::GetPawn().vLastCameraPos }; 101 | 102 | const Vector3 deltaPos{ pTargetPos - lpPos }; 103 | 104 | const float distPos{ GetMagnitude(deltaPos) }; 105 | 106 | constexpr float radToDegree{ 57.295776f }; 107 | targetAngle.x = -asinf(deltaPos.z / distPos) * radToDegree; 108 | targetAngle.y = atan2f(deltaPos.y, deltaPos.x) * radToDegree; 109 | 110 | NormalizePitch(targetAngle.x); 111 | 112 | return targetAngle; 113 | } 114 | 115 | bool Aimbot::Start(const std::vector& pTargets) 116 | { 117 | if (pTargets.empty()) return false; 118 | 119 | Entity cTarget{ GetEntTarget(pTargets) }; 120 | if (!cTarget.IsEntInit()) return false; 121 | 122 | // Updating the target only when the feature is off 123 | if (!ConsoleMenu::bTargetLock) 124 | cTargetLocked = cTarget; 125 | 126 | // Target locking feature 127 | if (ConsoleMenu::bTargetLock) 128 | ShotLockedTarget(); 129 | else 130 | ShotTarget(cTarget); 131 | 132 | return true; 133 | } 134 | 135 | bool Aimbot::ShotTarget(const Entity& pCTarget) 136 | { 137 | Entity entTarget(pCTarget); 138 | Vector3 targetAngle{}; 139 | 140 | // Bone target 141 | if (ConsoleMenu::bHeadPos) 142 | targetAngle = Aimbot::GetTargetAngle(entTarget.GetBonePos(Bone::head)); 143 | else 144 | targetAngle = Aimbot::GetTargetAngle(entTarget.GetBonePos(Bone::pelvis)); 145 | 146 | // FOV 147 | if (!Aimbot::IsTargetInFov(targetAngle)) 148 | return false; 149 | 150 | // Smoothing 151 | if (ConsoleMenu::smoothValue) 152 | LocalPlayer::SetSmoothViewAngles(targetAngle, ConsoleMenu::smoothValue); 153 | else 154 | LocalPlayer::SetViewAngles(targetAngle); 155 | 156 | return true; 157 | } 158 | 159 | bool Aimbot::ShotLockedTarget() 160 | { 161 | Entity entTargetLocked(Aimbot::cTargetLocked); 162 | Pawn entPawnLocked{ entTargetLocked.GetPawnBase() }; 163 | Vector3 targetLockedAngle{}; 164 | 165 | // Bone target 166 | if (ConsoleMenu::bHeadPos) 167 | targetLockedAngle = Aimbot::GetTargetAngle(entTargetLocked.GetBonePos(Bone::head)); 168 | else 169 | targetLockedAngle = Aimbot::GetTargetAngle(entTargetLocked.GetBonePos(Bone::pelvis)); 170 | 171 | // FOV 172 | if (!Aimbot::IsTargetInFov(targetLockedAngle)) 173 | return false; 174 | 175 | // Smoothing 176 | if (ConsoleMenu::smoothValue) 177 | LocalPlayer::SetSmoothViewAngles(targetLockedAngle, ConsoleMenu::smoothValue); 178 | else 179 | LocalPlayer::SetViewAngles(targetLockedAngle); 180 | 181 | // Locking at target until he die 182 | if (entPawnLocked.iHealth < 1) 183 | cTargetLocked = Entity(); 184 | 185 | return true; 186 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/CS2_Internal_Trainer.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {985bc006-a3bb-452f-bd8f-615a30eff199} 10 | 11 | 12 | {3dc26f74-e32f-4e67-b66c-124572380352} 13 | 14 | 15 | {c747f8e4-6bf7-447d-a52f-6b1b2cba2698} 16 | 17 | 18 | {69459702-d89f-47bb-97b2-837acbfe22a4} 19 | 20 | 21 | {bb4a1223-a56d-473b-afca-f00dec9d0d94} 22 | 23 | 24 | {a4ea7340-a01d-4fcd-9e41-3a57743dd886} 25 | 26 | 27 | {ff6bb25b-7531-46ac-9dcf-d6fd8e56ff69} 28 | 29 | 30 | {a7f72354-e5b1-4258-922c-e67298d1e17d} 31 | 32 | 33 | {70e8c3e6-db57-4755-a464-88e101053d45} 34 | 35 | 36 | 37 | 38 | Hook 39 | 40 | 41 | Menu 42 | 43 | 44 | Features\Aimbot 45 | 46 | 47 | Features\ESP\D3d11 48 | 49 | 50 | Features\ESP\D3d11 51 | 52 | 53 | Features 54 | 55 | 56 | Features\ESP\D3d11 57 | 58 | 59 | Features\ESP 60 | 61 | 62 | SDK 63 | 64 | 65 | Features\ESP\D3d11 66 | 67 | 68 | SDK\CS2_Dumper 69 | 70 | 71 | SDK\CS2_Dumper 72 | 73 | 74 | SDK\CS2_Dumper 75 | 76 | 77 | SDK\CS2_Dumper 78 | 79 | 80 | SDK\CS2_Dumper 81 | 82 | 83 | SDK\CS2_Dumper 84 | 85 | 86 | SDK\CS2_Dumper 87 | 88 | 89 | SDK\CS2_Dumper 90 | 91 | 92 | SDK\CS2_Dumper 93 | 94 | 95 | SDK\CS2_Dumper 96 | 97 | 98 | SDK\CS2_Dumper 99 | 100 | 101 | SDK\CS2_Dumper 102 | 103 | 104 | SDK\CS2_Dumper 105 | 106 | 107 | SDK\CS2_Dumper 108 | 109 | 110 | SDK\CS2_Dumper 111 | 112 | 113 | SDK\CS2_Dumper 114 | 115 | 116 | SDK\CS2_Dumper 117 | 118 | 119 | SDK\CS2_Dumper 120 | 121 | 122 | SDK\CS2_Dumper 123 | 124 | 125 | SDK\CS2_Dumper 126 | 127 | 128 | SDK\MemUtils 129 | 130 | 131 | SDK\MemUtils 132 | 133 | 134 | SDK\MemUtils 135 | 136 | 137 | SDK\MemUtils 138 | 139 | 140 | SDK 141 | 142 | 143 | SDK 144 | 145 | 146 | SDK 147 | 148 | 149 | 150 | 151 | main 152 | 153 | 154 | Menu 155 | 156 | 157 | Hook 158 | 159 | 160 | Features\ESP\D3d11 161 | 162 | 163 | Features\Aimbot 164 | 165 | 166 | Features 167 | 168 | 169 | Features\ESP 170 | 171 | 172 | SDK 173 | 174 | 175 | Features\ESP\D3d11 176 | 177 | 178 | SDK\MemUtils 179 | 180 | 181 | SDK\MemUtils 182 | 183 | 184 | SDK 185 | 186 | 187 | SDK 188 | 189 | 190 | SDK 191 | 192 | 193 | -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/schemasystem.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: schemasystem.dll 12 | // Classes count: 7 13 | // Enums count: 2 14 | namespace schemasystem_dll { 15 | // Alignment: 1 16 | // Members count: 81 17 | enum class fieldtype_t : uint8_t { 18 | FIELD_VOID = 0x0, 19 | FIELD_FLOAT32 = 0x1, 20 | FIELD_STRING = 0x2, 21 | FIELD_VECTOR = 0x3, 22 | FIELD_QUATERNION = 0x4, 23 | FIELD_INT32 = 0x5, 24 | FIELD_BOOLEAN = 0x6, 25 | FIELD_INT16 = 0x7, 26 | FIELD_CHARACTER = 0x8, 27 | FIELD_COLOR32 = 0x9, 28 | FIELD_EMBEDDED = 0xA, 29 | FIELD_CUSTOM = 0xB, 30 | FIELD_CLASSPTR = 0xC, 31 | FIELD_EHANDLE = 0xD, 32 | FIELD_POSITION_VECTOR = 0xE, 33 | FIELD_TIME = 0xF, 34 | FIELD_TICK = 0x10, 35 | FIELD_SOUNDNAME = 0x11, 36 | FIELD_INPUT = 0x12, 37 | FIELD_FUNCTION = 0x13, 38 | FIELD_VMATRIX = 0x14, 39 | FIELD_VMATRIX_WORLDSPACE = 0x15, 40 | FIELD_MATRIX3X4_WORLDSPACE = 0x16, 41 | FIELD_INTERVAL = 0x17, 42 | FIELD_UNUSED = 0x18, 43 | FIELD_VECTOR2D = 0x19, 44 | FIELD_INT64 = 0x1A, 45 | FIELD_VECTOR4D = 0x1B, 46 | FIELD_RESOURCE = 0x1C, 47 | FIELD_TYPEUNKNOWN = 0x1D, 48 | FIELD_CSTRING = 0x1E, 49 | FIELD_HSCRIPT = 0x1F, 50 | FIELD_VARIANT = 0x20, 51 | FIELD_UINT64 = 0x21, 52 | FIELD_FLOAT64 = 0x22, 53 | FIELD_POSITIVEINTEGER_OR_NULL = 0x23, 54 | FIELD_HSCRIPT_NEW_INSTANCE = 0x24, 55 | FIELD_UINT32 = 0x25, 56 | FIELD_UTLSTRINGTOKEN = 0x26, 57 | FIELD_QANGLE = 0x27, 58 | FIELD_NETWORK_ORIGIN_CELL_QUANTIZED_VECTOR = 0x28, 59 | FIELD_HMATERIAL = 0x29, 60 | FIELD_HMODEL = 0x2A, 61 | FIELD_NETWORK_QUANTIZED_VECTOR = 0x2B, 62 | FIELD_NETWORK_QUANTIZED_FLOAT = 0x2C, 63 | FIELD_DIRECTION_VECTOR_WORLDSPACE = 0x2D, 64 | FIELD_QANGLE_WORLDSPACE = 0x2E, 65 | FIELD_QUATERNION_WORLDSPACE = 0x2F, 66 | FIELD_HSCRIPT_LIGHTBINDING = 0x30, 67 | FIELD_V8_VALUE = 0x31, 68 | FIELD_V8_OBJECT = 0x32, 69 | FIELD_V8_ARRAY = 0x33, 70 | FIELD_V8_CALLBACK_INFO = 0x34, 71 | FIELD_UTLSTRING = 0x35, 72 | FIELD_NETWORK_ORIGIN_CELL_QUANTIZED_POSITION_VECTOR = 0x36, 73 | FIELD_HRENDERTEXTURE = 0x37, 74 | FIELD_HPARTICLESYSTEMDEFINITION = 0x38, 75 | FIELD_UINT8 = 0x39, 76 | FIELD_UINT16 = 0x3A, 77 | FIELD_CTRANSFORM = 0x3B, 78 | FIELD_CTRANSFORM_WORLDSPACE = 0x3C, 79 | FIELD_HPOSTPROCESSING = 0x3D, 80 | FIELD_MATRIX3X4 = 0x3E, 81 | FIELD_SHIM = 0x3F, 82 | FIELD_CMOTIONTRANSFORM = 0x40, 83 | FIELD_CMOTIONTRANSFORM_WORLDSPACE = 0x41, 84 | FIELD_ATTACHMENT_HANDLE = 0x42, 85 | FIELD_AMMO_INDEX = 0x43, 86 | FIELD_CONDITION_ID = 0x44, 87 | FIELD_AI_SCHEDULE_BITS = 0x45, 88 | FIELD_MODIFIER_HANDLE = 0x46, 89 | FIELD_ROTATION_VECTOR = 0x47, 90 | FIELD_ROTATION_VECTOR_WORLDSPACE = 0x48, 91 | FIELD_HVDATA = 0x49, 92 | FIELD_SCALE32 = 0x4A, 93 | FIELD_STRING_AND_TOKEN = 0x4B, 94 | FIELD_ENGINE_TIME = 0x4C, 95 | FIELD_ENGINE_TICK = 0x4D, 96 | FIELD_WORLD_GROUP_ID = 0x4E, 97 | FIELD_GLOBALSYMBOL = 0x4F, 98 | FIELD_TYPECOUNT = 0x50 99 | }; 100 | // Alignment: 4 101 | // Members count: 3 102 | enum class ThreeState_t : uint32_t { 103 | TRS_FALSE = 0x0, 104 | TRS_TRUE = 0x1, 105 | TRS_NONE = 0x2 106 | }; 107 | // Parent: None 108 | // Fields count: 0 109 | // 110 | // Metadata: 111 | // MResourceTypeForInfoType 112 | namespace InfoForResourceTypeCResourceManifestInternal { 113 | } 114 | // Parent: None 115 | // Fields count: 22 116 | namespace CSchemaSystemInternalRegistration { 117 | constexpr std::ptrdiff_t m_Vector2D = 0x0; // Vector2D 118 | constexpr std::ptrdiff_t m_Vector = 0x8; // Vector 119 | constexpr std::ptrdiff_t m_VectorAligned = 0x20; // VectorAligned 120 | constexpr std::ptrdiff_t m_Quaternion = 0x30; // Quaternion 121 | constexpr std::ptrdiff_t m_QAngle = 0x40; // QAngle 122 | constexpr std::ptrdiff_t m_RotationVector = 0x4C; // RotationVector 123 | constexpr std::ptrdiff_t m_RadianEuler = 0x58; // RadianEuler 124 | constexpr std::ptrdiff_t m_DegreeEuler = 0x64; // DegreeEuler 125 | constexpr std::ptrdiff_t m_QuaternionStorage = 0x70; // QuaternionStorage 126 | constexpr std::ptrdiff_t m_matrix3x4_t = 0x80; // matrix3x4_t 127 | constexpr std::ptrdiff_t m_matrix3x4a_t = 0xB0; // matrix3x4a_t 128 | constexpr std::ptrdiff_t m_Color = 0xE0; // Color 129 | constexpr std::ptrdiff_t m_Vector4D = 0xE4; // Vector4D 130 | constexpr std::ptrdiff_t m_CTransform = 0x100; // CTransform 131 | constexpr std::ptrdiff_t m_pKeyValues = 0x120; // KeyValues* 132 | constexpr std::ptrdiff_t m_CUtlBinaryBlock = 0x128; // CUtlBinaryBlock 133 | constexpr std::ptrdiff_t m_CUtlString = 0x140; // CUtlString 134 | constexpr std::ptrdiff_t m_CUtlSymbol = 0x148; // CUtlSymbol 135 | constexpr std::ptrdiff_t m_stringToken = 0x14C; // CUtlStringToken 136 | constexpr std::ptrdiff_t m_stringTokenWithStorage = 0x150; // CUtlStringTokenWithStorage 137 | constexpr std::ptrdiff_t m_ResourceTypes = 0x168; // CResourceArray> 138 | constexpr std::ptrdiff_t m_KV3 = 0x170; // KeyValues3 139 | } 140 | // Parent: CExampleSchemaVData_PolymorphicBase 141 | // Fields count: 1 142 | // 143 | // Metadata: 144 | // MGetKV3ClassDefaults 145 | namespace CExampleSchemaVData_PolymorphicDerivedA { 146 | constexpr std::ptrdiff_t m_nDerivedA = 0x10; // int32 147 | } 148 | // Parent: None 149 | // Fields count: 1 150 | // 151 | // Metadata: 152 | // MGetKV3ClassDefaults 153 | namespace CExampleSchemaVData_PolymorphicBase { 154 | constexpr std::ptrdiff_t m_nBase = 0x8; // int32 155 | } 156 | // Parent: CExampleSchemaVData_PolymorphicBase 157 | // Fields count: 1 158 | // 159 | // Metadata: 160 | // MGetKV3ClassDefaults 161 | namespace CExampleSchemaVData_PolymorphicDerivedB { 162 | constexpr std::ptrdiff_t m_nDerivedB = 0x10; // int32 163 | } 164 | // Parent: None 165 | // Fields count: 1 166 | namespace ResourceId_t { 167 | constexpr std::ptrdiff_t m_Value = 0x0; // uint64 168 | } 169 | // Parent: None 170 | // Fields count: 2 171 | // 172 | // Metadata: 173 | // MGetKV3ClassDefaults 174 | namespace CExampleSchemaVData_Monomorphic { 175 | constexpr std::ptrdiff_t m_nExample1 = 0x0; // int32 176 | constexpr std::ptrdiff_t m_nExample2 = 0x4; // int32 177 | } 178 | } 179 | } 180 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/PatternScan.cpp: -------------------------------------------------------------------------------- 1 | #include "PatternScan.h" 2 | 3 | intptr_t PatternScan::GetPatternSize(const std::string& pPattern) 4 | { 5 | if (pPattern.empty()) return NULL; 6 | 7 | int patternSize{ 0 }; 8 | bool bWildCard{ false }; 9 | 10 | for (int i{ 0 }; i < pPattern.length(); ++i) 11 | { 12 | if (pPattern[i] == '?') 13 | { 14 | bWildCard = true; 15 | continue; 16 | } 17 | else if (bWildCard && pPattern[i] == ' ') 18 | { 19 | ++patternSize; 20 | bWildCard = false; 21 | } 22 | else if (pPattern[i] != ' ') 23 | { 24 | ++patternSize; 25 | } 26 | } 27 | 28 | return patternSize; 29 | } 30 | 31 | std::vector PatternScan::GetParsedPattern(const std::string& pPattern) 32 | { 33 | if (pPattern.empty()) 34 | return std::vector(); 35 | 36 | std::vector parsedPattern{}; 37 | 38 | for (int i{ 0 }; i < pPattern.length(); i += 3) 39 | { 40 | if (pPattern[i] != ' ') 41 | { 42 | const std::string patternSub{ pPattern.substr(i, 2) }; 43 | 44 | // Deal with any wildcard type 45 | if (patternSub == "??") 46 | { 47 | parsedPattern.push_back('?'); 48 | continue; 49 | } 50 | else if (patternSub == "? ") 51 | { 52 | parsedPattern.push_back('?'); 53 | --i; // WildCard is only 1 byte so we have to inc by 2 54 | continue; 55 | } 56 | 57 | // Convert the substring into an hex byte 58 | const char hexByte{ static_cast(std::strtol(patternSub.c_str(), 0, 16)) }; 59 | 60 | if (!hexByte) 61 | return std::vector(); 62 | 63 | parsedPattern.push_back(hexByte); 64 | } 65 | } 66 | 67 | return parsedPattern; 68 | } 69 | 70 | intptr_t PatternScan::GetPatternAddr(char* pRegionAddr, intptr_t pRegionSize, const std::string& pPattern) 71 | { 72 | // Remove the spaces and formate the pattern into hex byte 73 | std::vector sPattern{ GetParsedPattern(pPattern) }; 74 | 75 | if (sPattern.empty()) 76 | return NULL; 77 | 78 | // Only iterate over the bytes that could potentially be the start of the pattern 79 | const uintptr_t regionSize{ pRegionSize - (sPattern.size()) }; 80 | 81 | for (uintptr_t i{ 0 }; i < regionSize; ++i) 82 | { 83 | bool bFound{ true }; 84 | 85 | for (uintptr_t j{ 0 }; j < sPattern.size(); ++j) 86 | { 87 | if (sPattern[j] != '?' && sPattern[j] != pRegionAddr[i + j]) 88 | { 89 | bFound = false; 90 | break; 91 | } 92 | } 93 | 94 | if (bFound) 95 | return reinterpret_cast(pRegionAddr) + i; 96 | } 97 | 98 | return 0; 99 | } 100 | 101 | intptr_t PatternScan::GetValidMemRegion(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 102 | { 103 | if (!pLdrEntry || pPattern.empty()) 104 | return 0; 105 | 106 | MEMORY_BASIC_INFORMATION mbi{}; 107 | 108 | char* modBaseAddr{ reinterpret_cast(pLdrEntry->DllBase) }; 109 | const intptr_t modSize{ pLdrEntry->SizeOfImage }; 110 | 111 | for (char* currRegion{ modBaseAddr }; currRegion < modBaseAddr + modSize; currRegion += mbi.RegionSize) 112 | { 113 | if (!VirtualQuery(currRegion, &mbi, sizeof(mbi)) || mbi.Protect == PAGE_NOACCESS || mbi.State != MEM_COMMIT) 114 | continue; 115 | 116 | const intptr_t patternRes{ GetPatternAddr(currRegion, mbi.RegionSize, pPattern) }; 117 | 118 | if (patternRes) return patternRes; 119 | } 120 | return 0; 121 | } 122 | 123 | intptr_t PatternScan::ExtractPointer(intptr_t pPatternResult) 124 | { 125 | intptr_t resultPointer{}; 126 | 127 | constexpr int opcodeSize{ 3 }; 128 | const int32_t offset{ *reinterpret_cast(pPatternResult + opcodeSize) }; 129 | 130 | constexpr int instructionSize{ 7 }; 131 | resultPointer = pPatternResult + static_cast(offset) + instructionSize; 132 | 133 | return resultPointer; 134 | } 135 | 136 | void PatternScan::SetGameEntitySystem(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 137 | { 138 | intptr_t resultPointer{}; 139 | 140 | // Get the address of the pattern result 141 | const intptr_t patternAddr{ GetValidMemRegion(pLdrEntry, pPattern) }; 142 | 143 | if (patternAddr) 144 | resultPointer = ExtractPointer(patternAddr); 145 | 146 | MyOffset::GPointers::GameEntitySyst = resultPointer - reinterpret_cast(pLdrEntry->DllBase); 147 | pointersState["GameEntitySystem"] = resultPointer; 148 | } 149 | 150 | void PatternScan::SetGameRules(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 151 | { 152 | intptr_t resultPointer{}; 153 | 154 | // Get the address of the pattern result 155 | const intptr_t patternAddr{ GetValidMemRegion(pLdrEntry, pPattern) }; 156 | 157 | if (patternAddr) 158 | resultPointer = ExtractPointer(patternAddr); 159 | 160 | MyOffset::GPointers::GameRules = resultPointer - reinterpret_cast(pLdrEntry->DllBase); 161 | pointersState["GameRules"] = resultPointer; 162 | } 163 | 164 | void PatternScan::SetLpController(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 165 | { 166 | intptr_t resultPointer{}; 167 | 168 | // Get the address of the pattern result 169 | const intptr_t patternAddr{ GetValidMemRegion(pLdrEntry, pPattern) }; 170 | 171 | if (patternAddr) 172 | resultPointer = ExtractPointer(patternAddr); 173 | 174 | MyOffset::GPointers::LP_Controller = resultPointer - reinterpret_cast(pLdrEntry->DllBase); 175 | pointersState["LP_Controller"] = resultPointer; 176 | } 177 | 178 | void PatternScan::SetViewMatrix(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 179 | { 180 | intptr_t resultPointer{}; 181 | 182 | // Get the address of the pattern result 183 | const intptr_t patternAddr{ GetValidMemRegion(pLdrEntry, pPattern) }; 184 | 185 | if (patternAddr) 186 | resultPointer = ExtractPointer(patternAddr); 187 | 188 | // Storing the offset of the pointer 189 | MyOffset::GPointers::ViewMatrix = resultPointer - reinterpret_cast(pLdrEntry->DllBase); 190 | 191 | pointersState["ViewMatrix"] = resultPointer; 192 | } 193 | 194 | void PatternScan::SetViewAngles(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 195 | { 196 | intptr_t* resultPointer{ nullptr }; 197 | 198 | // Get the address of the pattern result 199 | const intptr_t patternAddr{ GetValidMemRegion(pLdrEntry, pPattern) }; 200 | 201 | if (patternAddr) 202 | { 203 | resultPointer = reinterpret_cast(ExtractPointer(patternAddr)); 204 | 205 | // Dereference the pointer 2 times to access CCSGO_Input Base address 206 | for (int i{ 0 }; i < 2; ++i) 207 | resultPointer = reinterpret_cast(*resultPointer); 208 | 209 | // Storing the offset of the pointer 210 | const intptr_t CCSGO_InputOffset = reinterpret_cast(resultPointer) - MyOffset::GPointers::ClientMod; 211 | MyOffset::GPointers::ViewAngles = CCSGO_InputOffset - MyOffset::CCSGO_Input::ViewAngles; 212 | } 213 | 214 | pointersState["ViewAngles"] = reinterpret_cast(resultPointer); 215 | } 216 | 217 | void PatternScan::SetPrediction(LDR_DATA_TABLE_ENTRY* pLdrEntry, const std::string& pPattern) 218 | { 219 | intptr_t resultPointer{}; 220 | 221 | // Get the address of the pattern result 222 | const intptr_t patternAddr{ GetValidMemRegion(pLdrEntry, pPattern) }; 223 | 224 | if (patternAddr) 225 | resultPointer = ExtractPointer(patternAddr); 226 | 227 | // Storing the offset of the pointer 228 | MyOffset::GPointers::Prediction = resultPointer - reinterpret_cast(pLdrEntry->DllBase); 229 | 230 | pointersState["Prediction"] = resultPointer; 231 | } 232 | 233 | void PatternScan::SetClientMod(PVOID pDllBase) 234 | { 235 | MyOffset::GPointers::ClientMod = reinterpret_cast(pDllBase); 236 | pointersState["ClientDLL"] = MyOffset::GPointers::ClientMod; 237 | } 238 | 239 | void PatternScan::SetEngine2Mod(PVOID pDllBase) 240 | { 241 | MyOffset::GPointers::Engine2Mod = reinterpret_cast(pDllBase); 242 | pointersState["Engine2"] = MyOffset::GPointers::Engine2Mod; 243 | } 244 | 245 | bool PatternScan::InitPointers() 246 | { 247 | LDR_DATA_TABLE_ENTRY* clientLdr{ GetLdrEntry(L"client.dll") }; 248 | LDR_DATA_TABLE_ENTRY* engine2Ldr{ GetLdrEntry(L"engine2.dll") }; 249 | 250 | SetClientMod(clientLdr->DllBase); 251 | SetEngine2Mod(engine2Ldr->DllBase); 252 | 253 | SetGameRules(clientLdr, Pattern::GameRules); 254 | SetGameEntitySystem(clientLdr, Pattern::EntityList); 255 | SetLpController(clientLdr, Pattern::LP_Controller); 256 | SetViewMatrix(clientLdr, Pattern::ViewMatrix); 257 | SetPrediction(clientLdr, Pattern::Prediction); 258 | SetViewAngles(engine2Ldr, Pattern::CCSGoInput); 259 | 260 | return ArePointersInit(); 261 | } 262 | 263 | bool PatternScan::ArePointersInit() 264 | { 265 | for (const auto& pointer : pointersState) 266 | { 267 | if (!pointer.second) return false; 268 | } 269 | 270 | return true; 271 | } 272 | 273 | std::map PatternScan::GetPtrState() 274 | { 275 | return pointersState; 276 | } 277 | 278 | PEB* PatternScan::GetPEB() 279 | { 280 | return (PEB*)__readgsqword(0x60); 281 | } 282 | 283 | LDR_DATA_TABLE_ENTRY* PatternScan::GetLdrEntry(const wchar_t* pModName) 284 | { 285 | PEB* peb{ GetPEB() }; 286 | 287 | LIST_ENTRY headList{ peb->Ldr->InMemoryOrderModuleList }; 288 | LIST_ENTRY currList{ headList }; 289 | 290 | while (currList.Flink != headList.Blink) 291 | { 292 | LDR_DATA_TABLE_ENTRY* currLdrEntry{ CONTAINING_RECORD(currList.Flink, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks) }; 293 | 294 | if (currLdrEntry->FullDllName.Buffer) 295 | { 296 | wchar_t* wNameBuffer{ currLdrEntry->BaseDllName.Buffer }; 297 | 298 | // Equal 299 | if (wcscmp(wNameBuffer, pModName) == 0) 300 | return currLdrEntry; 301 | } 302 | currList = *currList.Flink; 303 | } 304 | 305 | return nullptr; 306 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/materialsystem2.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: materialsystem2.dll 12 | // Classes count: 13 13 | // Enums count: 5 14 | namespace materialsystem2_dll { 15 | // Alignment: 4 16 | // Members count: 4 17 | enum class VertJustification_e : uint32_t { 18 | VERT_JUSTIFICATION_TOP = 0x0, 19 | VERT_JUSTIFICATION_CENTER = 0x1, 20 | VERT_JUSTIFICATION_BOTTOM = 0x2, 21 | VERT_JUSTIFICATION_NONE = 0x3 22 | }; 23 | // Alignment: 4 24 | // Members count: 3 25 | enum class LayoutPositionType_e : uint32_t { 26 | LAYOUTPOSITIONTYPE_VIEWPORT_RELATIVE = 0x0, 27 | LAYOUTPOSITIONTYPE_FRACTIONAL = 0x1, 28 | LAYOUTPOSITIONTYPE_NONE = 0x2 29 | }; 30 | // Alignment: 4 31 | // Members count: 3 32 | enum class ViewFadeMode_t : uint32_t { 33 | VIEW_FADE_CONSTANT_COLOR = 0x0, 34 | VIEW_FADE_MODULATE = 0x1, 35 | VIEW_FADE_MOD2X = 0x2 36 | }; 37 | // Alignment: 4 38 | // Members count: 3 39 | enum class BloomBlendMode_t : uint32_t { 40 | BLOOM_BLEND_ADD = 0x0, 41 | BLOOM_BLEND_SCREEN = 0x1, 42 | BLOOM_BLEND_BLUR = 0x2 43 | }; 44 | // Alignment: 4 45 | // Members count: 4 46 | enum class HorizJustification_e : uint32_t { 47 | HORIZ_JUSTIFICATION_LEFT = 0x0, 48 | HORIZ_JUSTIFICATION_CENTER = 0x1, 49 | HORIZ_JUSTIFICATION_RIGHT = 0x2, 50 | HORIZ_JUSTIFICATION_NONE = 0x3 51 | }; 52 | // Parent: None 53 | // Fields count: 1 54 | // 55 | // Metadata: 56 | // MGetKV3ClassDefaults 57 | namespace MaterialParam_t { 58 | constexpr std::ptrdiff_t m_name = 0x0; // CUtlString 59 | } 60 | // Parent: MaterialParam_t 61 | // Fields count: 1 62 | // 63 | // Metadata: 64 | // MGetKV3ClassDefaults 65 | namespace MaterialParamVector_t { 66 | constexpr std::ptrdiff_t m_value = 0x8; // Vector4D 67 | } 68 | // Parent: MaterialParam_t 69 | // Fields count: 1 70 | // 71 | // Metadata: 72 | // MGetKV3ClassDefaults 73 | namespace MaterialParamString_t { 74 | constexpr std::ptrdiff_t m_value = 0x8; // CUtlString 75 | } 76 | // Parent: None 77 | // Fields count: 11 78 | // 79 | // Metadata: 80 | // MGetKV3ClassDefaults 81 | namespace PostProcessingResource_t { 82 | constexpr std::ptrdiff_t m_bHasTonemapParams = 0x0; // bool 83 | constexpr std::ptrdiff_t m_toneMapParams = 0x4; // PostProcessingTonemapParameters_t 84 | constexpr std::ptrdiff_t m_bHasBloomParams = 0x40; // bool 85 | constexpr std::ptrdiff_t m_bloomParams = 0x44; // PostProcessingBloomParameters_t 86 | constexpr std::ptrdiff_t m_bHasVignetteParams = 0xB4; // bool 87 | constexpr std::ptrdiff_t m_vignetteParams = 0xB8; // PostProcessingVignetteParameters_t 88 | constexpr std::ptrdiff_t m_bHasLocalContrastParams = 0xDC; // bool 89 | constexpr std::ptrdiff_t m_localConstrastParams = 0xE0; // PostProcessingLocalContrastParameters_t 90 | constexpr std::ptrdiff_t m_nColorCorrectionVolumeDim = 0xF4; // int32 91 | constexpr std::ptrdiff_t m_colorCorrectionVolumeData = 0xF8; // CUtlBinaryBlock 92 | constexpr std::ptrdiff_t m_bHasColorCorrection = 0x110; // bool 93 | } 94 | // Parent: MaterialParam_t 95 | // Fields count: 1 96 | // 97 | // Metadata: 98 | // MGetKV3ClassDefaults 99 | namespace MaterialParamInt_t { 100 | constexpr std::ptrdiff_t m_nValue = 0x8; // int32 101 | } 102 | // Parent: None 103 | // Fields count: 6 104 | // 105 | // Metadata: 106 | // MGetKV3ClassDefaults 107 | namespace PostProcessingVignetteParameters_t { 108 | constexpr std::ptrdiff_t m_flVignetteStrength = 0x0; // float32 109 | constexpr std::ptrdiff_t m_vCenter = 0x4; // Vector2D 110 | constexpr std::ptrdiff_t m_flRadius = 0xC; // float32 111 | constexpr std::ptrdiff_t m_flRoundness = 0x10; // float32 112 | constexpr std::ptrdiff_t m_flFeather = 0x14; // float32 113 | constexpr std::ptrdiff_t m_vColorTint = 0x18; // Vector 114 | } 115 | // Parent: None 116 | // Fields count: 5 117 | // 118 | // Metadata: 119 | // MGetKV3ClassDefaults 120 | namespace PostProcessingLocalContrastParameters_t { 121 | constexpr std::ptrdiff_t m_flLocalContrastStrength = 0x0; // float32 122 | constexpr std::ptrdiff_t m_flLocalContrastEdgeStrength = 0x4; // float32 123 | constexpr std::ptrdiff_t m_flLocalContrastVignetteStart = 0x8; // float32 124 | constexpr std::ptrdiff_t m_flLocalContrastVignetteEnd = 0xC; // float32 125 | constexpr std::ptrdiff_t m_flLocalContrastVignetteBlur = 0x10; // float32 126 | } 127 | // Parent: None 128 | // Fields count: 15 129 | // 130 | // Metadata: 131 | // MGetKV3ClassDefaults 132 | namespace PostProcessingTonemapParameters_t { 133 | constexpr std::ptrdiff_t m_flExposureBias = 0x0; // float32 134 | constexpr std::ptrdiff_t m_flShoulderStrength = 0x4; // float32 135 | constexpr std::ptrdiff_t m_flLinearStrength = 0x8; // float32 136 | constexpr std::ptrdiff_t m_flLinearAngle = 0xC; // float32 137 | constexpr std::ptrdiff_t m_flToeStrength = 0x10; // float32 138 | constexpr std::ptrdiff_t m_flToeNum = 0x14; // float32 139 | constexpr std::ptrdiff_t m_flToeDenom = 0x18; // float32 140 | constexpr std::ptrdiff_t m_flWhitePoint = 0x1C; // float32 141 | constexpr std::ptrdiff_t m_flLuminanceSource = 0x20; // float32 142 | constexpr std::ptrdiff_t m_flExposureBiasShadows = 0x24; // float32 143 | constexpr std::ptrdiff_t m_flExposureBiasHighlights = 0x28; // float32 144 | constexpr std::ptrdiff_t m_flMinShadowLum = 0x2C; // float32 145 | constexpr std::ptrdiff_t m_flMaxShadowLum = 0x30; // float32 146 | constexpr std::ptrdiff_t m_flMinHighlightLum = 0x34; // float32 147 | constexpr std::ptrdiff_t m_flMaxHighlightLum = 0x38; // float32 148 | } 149 | // Parent: MaterialParam_t 150 | // Fields count: 1 151 | // 152 | // Metadata: 153 | // MGetKV3ClassDefaults 154 | namespace MaterialParamBuffer_t { 155 | constexpr std::ptrdiff_t m_value = 0x8; // CUtlBinaryBlock 156 | } 157 | // Parent: None 158 | // Fields count: 14 159 | // 160 | // Metadata: 161 | // MGetKV3ClassDefaults 162 | namespace MaterialResourceData_t { 163 | constexpr std::ptrdiff_t m_materialName = 0x0; // CUtlString 164 | constexpr std::ptrdiff_t m_shaderName = 0x8; // CUtlString 165 | constexpr std::ptrdiff_t m_intParams = 0x10; // CUtlVector 166 | constexpr std::ptrdiff_t m_floatParams = 0x28; // CUtlVector 167 | constexpr std::ptrdiff_t m_vectorParams = 0x40; // CUtlVector 168 | constexpr std::ptrdiff_t m_textureParams = 0x58; // CUtlVector 169 | constexpr std::ptrdiff_t m_dynamicParams = 0x70; // CUtlVector 170 | constexpr std::ptrdiff_t m_dynamicTextureParams = 0x88; // CUtlVector 171 | constexpr std::ptrdiff_t m_intAttributes = 0xA0; // CUtlVector 172 | constexpr std::ptrdiff_t m_floatAttributes = 0xB8; // CUtlVector 173 | constexpr std::ptrdiff_t m_vectorAttributes = 0xD0; // CUtlVector 174 | constexpr std::ptrdiff_t m_textureAttributes = 0xE8; // CUtlVector 175 | constexpr std::ptrdiff_t m_stringAttributes = 0x100; // CUtlVector 176 | constexpr std::ptrdiff_t m_renderAttributesUsed = 0x118; // CUtlVector 177 | } 178 | // Parent: None 179 | // Fields count: 10 180 | // 181 | // Metadata: 182 | // MGetKV3ClassDefaults 183 | namespace PostProcessingBloomParameters_t { 184 | constexpr std::ptrdiff_t m_blendMode = 0x0; // BloomBlendMode_t 185 | constexpr std::ptrdiff_t m_flBloomStrength = 0x4; // float32 186 | constexpr std::ptrdiff_t m_flScreenBloomStrength = 0x8; // float32 187 | constexpr std::ptrdiff_t m_flBlurBloomStrength = 0xC; // float32 188 | constexpr std::ptrdiff_t m_flBloomThreshold = 0x10; // float32 189 | constexpr std::ptrdiff_t m_flBloomThresholdWidth = 0x14; // float32 190 | constexpr std::ptrdiff_t m_flSkyboxBloomStrength = 0x18; // float32 191 | constexpr std::ptrdiff_t m_flBloomStartValue = 0x1C; // float32 192 | constexpr std::ptrdiff_t m_flBlurWeight = 0x20; // float32[5] 193 | constexpr std::ptrdiff_t m_vBlurTint = 0x34; // Vector[5] 194 | } 195 | // Parent: MaterialParam_t 196 | // Fields count: 1 197 | // 198 | // Metadata: 199 | // MGetKV3ClassDefaults 200 | namespace MaterialParamFloat_t { 201 | constexpr std::ptrdiff_t m_flValue = 0x8; // float32 202 | } 203 | // Parent: MaterialParam_t 204 | // Fields count: 1 205 | // 206 | // Metadata: 207 | // MGetKV3ClassDefaults 208 | namespace MaterialParamTexture_t { 209 | constexpr std::ptrdiff_t m_pValue = 0x8; // CStrongHandle 210 | } 211 | } 212 | } 213 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/Cheats/ESP/D3D11/MyD3d11.cpp: -------------------------------------------------------------------------------- 1 | #include "MyD3D11.h" 2 | 3 | MyD3D11::~MyD3D11() 4 | { 5 | SafeRelease(m_constantBuffer); 6 | SafeRelease(m_vertexBuffer); 7 | SafeRelease(m_vInputLayout); 8 | SafeRelease(m_vertexShader); 9 | SafeRelease(m_pixelShader); 10 | } 11 | 12 | void MyD3D11::SafeRelease(auto*& pData) 13 | { 14 | if (pData) 15 | { 16 | pData->Release(); 17 | pData = nullptr; 18 | } 19 | } 20 | 21 | bool MyD3D11::SetInputLayout(ID3D10Blob* pCompiledShaderBlob) 22 | { 23 | const D3D11_INPUT_ELEMENT_DESC layout[2] = { 24 | {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}, 25 | {"COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0} 26 | }; 27 | 28 | const UINT numElements{ ARRAYSIZE(layout) }; 29 | 30 | const HRESULT hRes{ m_device->CreateInputLayout(layout, numElements, pCompiledShaderBlob->GetBufferPointer(), pCompiledShaderBlob->GetBufferSize(), &m_vInputLayout) }; 31 | 32 | if (FAILED(hRes)) return false; 33 | 34 | return true; 35 | } 36 | 37 | void MyD3D11::SetOrthoMatrix(D3D11_VIEWPORT pViewport) 38 | { 39 | m_orthoMatrix = DirectX::XMMatrixOrthographicOffCenterLH(0, pViewport.Width, pViewport.Height, 0, 0.0f, 1.0f); 40 | } 41 | 42 | bool MyD3D11::CompileShader(const char* szShader, const char* szEntrypoint, const char* szTarget, ID3D10Blob** compiledShaderBlob) 43 | { 44 | ID3D10Blob* pErrorBlob{ nullptr }; 45 | 46 | const auto hRes{ D3DCompile(szShader, strlen(szShader), 0, nullptr, nullptr, szEntrypoint, szTarget, D3DCOMPILE_ENABLE_STRICTNESS, 0, compiledShaderBlob, &pErrorBlob) }; 47 | if (FAILED(hRes)) 48 | { 49 | if (pErrorBlob) 50 | { 51 | char szError[256]{ 0 }; 52 | memcpy(szError, pErrorBlob->GetBufferPointer(), pErrorBlob->GetBufferSize()); 53 | MessageBoxA(nullptr, szError, "Error", MB_OK); 54 | } 55 | return false; 56 | } 57 | return true; 58 | } 59 | 60 | bool MyD3D11::CompileShaders() 61 | { 62 | ID3D10Blob* compiledShaderBlob{ nullptr }; 63 | 64 | // Vertex shader 65 | if (!CompileShader(shaders, "VS", "vs_5_0", &compiledShaderBlob)) 66 | return false; 67 | 68 | HRESULT hRes{ m_device->CreateVertexShader(compiledShaderBlob->GetBufferPointer(), compiledShaderBlob->GetBufferSize(), nullptr, &m_vertexShader) }; 69 | if (FAILED(hRes)) return false; 70 | 71 | // Sets the input layout of the vertex buffer 72 | if (!SetInputLayout(compiledShaderBlob)) 73 | return false; 74 | 75 | SafeRelease(compiledShaderBlob); 76 | 77 | // Pixel shader 78 | if (!CompileShader(shaders, "PS", "ps_5_0", &compiledShaderBlob)) 79 | return false; 80 | 81 | hRes = m_device->CreatePixelShader(compiledShaderBlob->GetBufferPointer(), compiledShaderBlob->GetBufferSize(), nullptr, &m_pixelShader); 82 | if (FAILED(hRes)) return false; 83 | 84 | return true; 85 | } 86 | 87 | bool MyD3D11::SetViewport() 88 | { 89 | m_hwnd = GetSwapHwnd(m_swapChain); 90 | 91 | if (!GetClientRect(m_hwnd, &m_hRect)) 92 | return false; 93 | 94 | // Setup viewport 95 | m_viewport.Width = static_cast(m_hRect.right); 96 | m_viewport.Height = static_cast(m_hRect.bottom); 97 | m_viewport.TopLeftX = static_cast(m_hRect.left); 98 | m_viewport.TopLeftY = static_cast(m_hRect.top); 99 | m_viewport.MinDepth = 0.0f; 100 | m_viewport.MaxDepth = 1.0f; 101 | 102 | return true; 103 | } 104 | 105 | bool MyD3D11::SetConstantBuffer() 106 | { 107 | SetOrthoMatrix(m_viewport); 108 | 109 | D3D11_BUFFER_DESC buffer_desc{ 0 }; 110 | buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; 111 | buffer_desc.ByteWidth = sizeof(DirectX::XMMATRIX); 112 | buffer_desc.Usage = D3D11_USAGE_DEFAULT; 113 | 114 | D3D11_SUBRESOURCE_DATA subResourceLine{ 0 }; 115 | subResourceLine.pSysMem = &m_orthoMatrix; 116 | 117 | HRESULT hRes{ m_device->CreateBuffer(&buffer_desc, &subResourceLine, &m_constantBuffer) }; 118 | if (FAILED(hRes)) return false; 119 | 120 | return true; 121 | } 122 | 123 | bool MyD3D11::SetDeviceContextRenderTarget() 124 | { 125 | // Get game device 126 | HRESULT hRes{ m_swapChain->GetDevice(__uuidof(ID3D11Device), (void**)&m_device) }; 127 | if (FAILED(hRes)) return false; 128 | 129 | m_device->GetImmediateContext(&m_context); 130 | 131 | // Init Render Target View 132 | ID3D11Texture2D* backBuffer{ nullptr }; 133 | hRes = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&backBuffer); 134 | if (FAILED(hRes)) return false; 135 | 136 | hRes = m_device->CreateRenderTargetView(backBuffer, nullptr, &m_renderTargetView); 137 | backBuffer->Release(); 138 | if (FAILED(hRes)) return false; 139 | 140 | return true; 141 | } 142 | 143 | bool MyD3D11::InitDraw(IDXGISwapChain* pSwapchain) 144 | { 145 | m_swapChain = pSwapchain; 146 | 147 | if (!SetDeviceContextRenderTarget()) return false; 148 | 149 | if (!CompileShaders()) return false; 150 | 151 | if (!SetViewport()) return false; 152 | 153 | if (!SetConstantBuffer()) return false; 154 | 155 | return true; 156 | } 157 | 158 | bool MyD3D11::SetO_Present() 159 | { 160 | DXGI_SWAP_CHAIN_DESC sd{ 0 }; 161 | sd.BufferCount = 1; 162 | sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; 163 | sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; 164 | sd.OutputWindow = MyD3D_Utils::FindMainWindow(GetCurrentProcessId()); 165 | sd.Windowed = TRUE; 166 | sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; 167 | sd.SampleDesc.Count = 1; 168 | 169 | ID3D11Device* device{ nullptr }; 170 | IDXGISwapChain* swapChain{ nullptr }; 171 | 172 | const HRESULT hRes{ D3D11CreateDeviceAndSwapChain( 173 | nullptr, 174 | D3D_DRIVER_TYPE_HARDWARE, 175 | nullptr, 176 | 0, 177 | nullptr, 178 | 0, 179 | D3D11_SDK_VERSION, 180 | &sd, 181 | &swapChain, 182 | &device, 183 | nullptr, 184 | nullptr) }; 185 | 186 | if (FAILED(hRes)) return false; 187 | 188 | void** pVMT{ *reinterpret_cast(swapChain) }; 189 | 190 | // Get Present's address out of vmt 191 | o_Present = (T_Present)(pVMT[(UINT)IDXGISwapChainVMT::Present]); 192 | 193 | SafeRelease(swapChain); 194 | SafeRelease(device); 195 | 196 | return true; 197 | } 198 | 199 | void MyD3D11::SetInputAssembler(D3D_PRIMITIVE_TOPOLOGY pPrimitiveTopology) 200 | { 201 | const UINT stride{ sizeof(Vertex) }; 202 | const UINT offset{ 0 }; 203 | 204 | m_context->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset); 205 | m_context->IASetInputLayout(m_vInputLayout); 206 | m_context->IASetPrimitiveTopology(pPrimitiveTopology); 207 | } 208 | 209 | void MyD3D11::SetLineVBuffer(float x, float y, float x2, float y2, D3DCOLORVALUE pColor) 210 | { 211 | Vertex vertices[2] = { 212 | { DirectX::XMFLOAT3(x, y, 1.0f), pColor }, 213 | { DirectX::XMFLOAT3(x2, y2, 1.0f), pColor }, 214 | }; 215 | 216 | D3D11_BUFFER_DESC buffer_desc_line{ 0 }; 217 | buffer_desc_line.BindFlags = D3D11_BIND_INDEX_BUFFER; 218 | buffer_desc_line.ByteWidth = sizeof(Vertex) * 2; 219 | buffer_desc_line.Usage = D3D11_USAGE_DEFAULT; 220 | 221 | D3D11_SUBRESOURCE_DATA subResourceLine{ 0 }; 222 | subResourceLine.pSysMem = &vertices; 223 | 224 | m_device->CreateBuffer(&buffer_desc_line, &subResourceLine, &m_vertexBuffer); 225 | } 226 | 227 | void MyD3D11::DrawLine(float x, float y, float x2, float y2, D3DCOLORVALUE pColor) 228 | { 229 | // Setup vertices 230 | SetLineVBuffer(x, y, x2, y2, pColor); 231 | 232 | // Input Assembler 233 | SetInputAssembler(D3D11_PRIMITIVE_TOPOLOGY_LINELIST); 234 | 235 | // Vertex Shader 236 | m_context->VSSetConstantBuffers(0, 1, &m_constantBuffer); 237 | m_context->VSSetShader(m_vertexShader, nullptr, 0); 238 | 239 | // Pixel Shader 240 | m_context->PSSetShader(m_pixelShader, nullptr, 0); 241 | 242 | // Output Merger 243 | m_context->OMSetRenderTargets(1, &m_renderTargetView, nullptr); 244 | 245 | // Rasterizer 246 | m_context->RSSetViewports(1, &m_viewport); 247 | 248 | m_context->Draw(2, 0); 249 | } 250 | 251 | void MyD3D11::SetLineWHVBuffer(float pX, float pY, float pWidth, float pHeight, D3DCOLORVALUE pColor) 252 | { 253 | Vertex vertices[2] = { 254 | { DirectX::XMFLOAT3(pX, pY, 1.0f), pColor }, 255 | { DirectX::XMFLOAT3(pX + pWidth, pY + pHeight, 1.0f), pColor }, 256 | }; 257 | 258 | D3D11_BUFFER_DESC buffer_desc_line{ 0 }; 259 | buffer_desc_line.BindFlags = D3D11_BIND_INDEX_BUFFER; 260 | buffer_desc_line.ByteWidth = sizeof(Vertex) * 2; 261 | buffer_desc_line.Usage = D3D11_USAGE_DEFAULT; 262 | 263 | D3D11_SUBRESOURCE_DATA subResourceLine{ 0 }; 264 | subResourceLine.pSysMem = &vertices; 265 | 266 | m_device->CreateBuffer(&buffer_desc_line, &subResourceLine, &m_vertexBuffer); 267 | } 268 | 269 | void MyD3D11::DrawLineWH(float pX, float pY, float pWidth, float pHeight, D3DCOLORVALUE pColor) 270 | { 271 | // Setup vertices 272 | SetLineWHVBuffer(pX, pY, pWidth, pHeight, pColor); 273 | 274 | // Input Assembler 275 | SetInputAssembler(D3D11_PRIMITIVE_TOPOLOGY_LINELIST); 276 | 277 | // Vertex Shader 278 | m_context->VSSetConstantBuffers(0, 1, &m_constantBuffer); 279 | m_context->VSSetShader(m_vertexShader, nullptr, 0); 280 | 281 | // Pixel Shader 282 | m_context->PSSetShader(m_pixelShader, nullptr, 0); 283 | 284 | // Output Merger 285 | m_context->OMSetRenderTargets(1, &m_renderTargetView, nullptr); 286 | 287 | // Rasterizer 288 | m_context->RSSetViewports(1, &m_viewport); 289 | 290 | m_context->Draw(2, 0); 291 | } 292 | 293 | void MyD3D11::SetBoxVBuffer(float pX, float pY, float pWidth, float pHeight, D3DCOLORVALUE pColor) 294 | { 295 | Vertex vertices[5] = { 296 | { DirectX::XMFLOAT3(pX, pY, 1.0f), pColor }, 297 | { DirectX::XMFLOAT3(pX + pWidth, pY, 1.0f), pColor }, 298 | { DirectX::XMFLOAT3(pX + pWidth, pY + pHeight, 1.0f), pColor }, 299 | { DirectX::XMFLOAT3(pX, pY + pHeight, 1.0f), pColor }, 300 | { DirectX::XMFLOAT3(pX, pY, 1.0f), pColor } 301 | }; 302 | 303 | D3D11_BUFFER_DESC buffer_desc_line{ 0 }; 304 | buffer_desc_line.BindFlags = D3D11_BIND_INDEX_BUFFER; 305 | buffer_desc_line.ByteWidth = sizeof(Vertex) * 5; 306 | buffer_desc_line.Usage = D3D11_USAGE_DEFAULT; 307 | 308 | D3D11_SUBRESOURCE_DATA subResourceLine{ 0 }; 309 | subResourceLine.pSysMem = &vertices; 310 | 311 | m_device->CreateBuffer(&buffer_desc_line, &subResourceLine, &m_vertexBuffer); 312 | } 313 | 314 | void MyD3D11::DrawBox(float pX, float pY, float pWidth, float pHeight, D3DCOLORVALUE pColor) 315 | { 316 | // Setup vertices TL, TR, BR, BL 317 | SetBoxVBuffer(pX, pY, pWidth, pHeight, pColor); 318 | 319 | // Input Assembler 320 | SetInputAssembler(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP); 321 | 322 | // Vertex Shader 323 | m_context->VSSetConstantBuffers(0, 1, &m_constantBuffer); 324 | m_context->VSSetShader(m_vertexShader, nullptr, 0); 325 | 326 | // Pixel Shader 327 | m_context->PSSetShader(m_pixelShader, nullptr, 0); 328 | 329 | // Output Merger 330 | m_context->OMSetRenderTargets(1, &m_renderTargetView, nullptr); 331 | 332 | // Rasterizer 333 | m_context->RSSetViewports(1, &m_viewport); 334 | 335 | m_context->Draw(5, 0); 336 | } 337 | 338 | HWND MyD3D11::GetSwapHwnd(IDXGISwapChain* pSwapchain) 339 | { 340 | DXGI_SWAP_CHAIN_DESC swapDesc; 341 | pSwapchain->GetDesc(&swapDesc); 342 | 343 | return swapDesc.OutputWindow; 344 | } 345 | 346 | void MyD3D11::TestRender() 347 | { 348 | //Draw from top left to bottom right if the viewport is correctly setup 349 | DrawLine(0, 0, 640, 360, MyD3D_Utils::green); 350 | DrawLine(0, 0, 640, -360, MyD3D_Utils::red); 351 | DrawLine(0, 0, -640, 360, MyD3D_Utils::magenta); 352 | DrawLine(0, 0, -640, -360, MyD3D_Utils::yellow); 353 | DrawBox(0, 0, 50, 100, MyD3D_Utils::green); 354 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/CS2_Internal_Trainer.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 17.0 23 | Win32Proj 24 | {9361a7bc-f8af-420b-a79e-66e1aefb153f} 25 | CS2InternalTrainer 26 | 10.0 27 | CS2_Internal_Trainer 28 | 29 | 30 | 31 | DynamicLibrary 32 | true 33 | v143 34 | Unicode 35 | 36 | 37 | DynamicLibrary 38 | false 39 | v143 40 | true 41 | Unicode 42 | 43 | 44 | DynamicLibrary 45 | true 46 | v143 47 | Unicode 48 | 49 | 50 | DynamicLibrary 51 | false 52 | v143 53 | true 54 | Unicode 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | $(VC_IncludePath);$(WindowsSDK_IncludePath);$(ProjectDir)Cheats\Aimbot;$(ProjectDir)\Menu;$(ProjectDir)\SDK;$(ProjectDir)Hook;$(ProjectDir)SDK\MemUtils;$(ProjectDir)\Cheats;$(ProjectDir)Cheats\ESP;$(ProjectDir)Cheats\ESP\D3D11;$(ProjectDir)Hook;$(ProjectDir)Cheats\ESP;$(ProjectDir)Hook;$(ProjectDir)Cheats\ESP;$(ProjectDir)SDK\CS2_Dumper; 76 | $(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64) 77 | 78 | 79 | $(VC_IncludePath);$(WindowsSDK_IncludePath);$(ProjectDir)Cheats\Aimbot;$(ProjectDir)\Menu;$(ProjectDir)\SDK;$(ProjectDir)Hook;$(ProjectDir)SDK\MemUtils;$(ProjectDir)\Cheats;$(ProjectDir)Cheats\ESP;$(ProjectDir)Cheats\ESP\D3D11;$(ProjectDir)Hook;$(ProjectDir)Cheats\ESP;$(ProjectDir)Hook;$(ProjectDir)Cheats\ESP;$(ProjectDir)SDK\CS2_Dumper; 80 | 81 | 82 | 83 | Level3 84 | true 85 | WIN32;_DEBUG;CS2INTERNALTRAINER_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 86 | true 87 | Use 88 | pch.h 89 | stdcpp20 90 | 91 | 92 | Windows 93 | true 94 | false 95 | 96 | 97 | 98 | 99 | Level3 100 | true 101 | true 102 | true 103 | WIN32;NDEBUG;CS2INTERNALTRAINER_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 104 | true 105 | Use 106 | pch.h 107 | 108 | 109 | Windows 110 | true 111 | true 112 | true 113 | false 114 | 115 | 116 | 117 | 118 | Level3 119 | true 120 | _DEBUG;CS2INTERNALTRAINER_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 121 | true 122 | NotUsing 123 | pch.h 124 | stdcpp20 125 | false 126 | 127 | 128 | Windows 129 | true 130 | false 131 | RequireAdministrator 132 | $(CoreLibraryDependencies);%(AdditionalDependencies);imagehlp.lib 133 | 134 | 135 | 136 | 137 | Level3 138 | true 139 | true 140 | true 141 | NDEBUG;CS2INTERNALTRAINER_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) 142 | true 143 | NotUsing 144 | pch.h 145 | stdcpp20 146 | 147 | 148 | Windows 149 | true 150 | true 151 | true 152 | false 153 | RequireAdministrator 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/Peb.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #define GDI_HANDLE_BUFFER_SIZE32 34 5 | #define GDI_HANDLE_BUFFER_SIZE64 60 6 | 7 | #ifndef _WIN64 8 | #define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE32 9 | #else 10 | #define GDI_HANDLE_BUFFER_SIZE GDI_HANDLE_BUFFER_SIZE64 11 | #endif 12 | 13 | typedef ULONG GDI_HANDLE_BUFFER32[GDI_HANDLE_BUFFER_SIZE32]; 14 | typedef ULONG GDI_HANDLE_BUFFER64[GDI_HANDLE_BUFFER_SIZE64]; 15 | typedef ULONG GDI_HANDLE_BUFFER[GDI_HANDLE_BUFFER_SIZE]; 16 | 17 | #define RTL_MAX_DRIVE_LETTERS 32 18 | 19 | #define RTL_BALANCED_NODE_RESERVED_PARENT_MASK 3 20 | 21 | typedef struct _RTL_BALANCED_NODE 22 | { 23 | union 24 | { 25 | struct _RTL_BALANCED_NODE* Children[2]; 26 | struct 27 | { 28 | struct _RTL_BALANCED_NODE* Left; 29 | struct _RTL_BALANCED_NODE* Right; 30 | } s; 31 | } u1; 32 | union 33 | { 34 | UCHAR Red : 1; 35 | UCHAR Balance : 2; 36 | ULONG_PTR ParentValue; 37 | } u2; 38 | } RTL_BALANCED_NODE, * PRTL_BALANCED_NODE; 39 | 40 | typedef enum _LDR_DLL_LOAD_REASON 41 | { 42 | LoadReasonStaticDependency, 43 | LoadReasonStaticForwarderDependency, 44 | LoadReasonDynamicForwarderDependency, 45 | LoadReasonDelayloadDependency, 46 | LoadReasonDynamicLoad, 47 | LoadReasonAsImageLoad, 48 | LoadReasonAsDataLoad, 49 | LoadReasonEnclavePrimary, // REDSTONE3 50 | LoadReasonEnclaveDependency, 51 | LoadReasonUnknown = -1 52 | } LDR_DLL_LOAD_REASON, * PLDR_DLL_LOAD_REASON; 53 | 54 | typedef struct _UNICODE_STRING 55 | { 56 | USHORT Length; 57 | USHORT MaximumLength; 58 | PWSTR Buffer; 59 | } UNICODE_STRING, * PUNICODE_STRING; 60 | typedef const UNICODE_STRING* PCUNICODE_STRING; 61 | 62 | typedef enum _LDR_DDAG_STATE 63 | { 64 | LdrModulesMerged = -5, 65 | LdrModulesInitError = -4, 66 | LdrModulesSnapError = -3, 67 | LdrModulesUnloaded = -2, 68 | LdrModulesUnloading = -1, 69 | LdrModulesPlaceHolder = 0, 70 | LdrModulesMapping = 1, 71 | LdrModulesMapped = 2, 72 | LdrModulesWaitingForDependencies = 3, 73 | LdrModulesSnapping = 4, 74 | LdrModulesSnapped = 5, 75 | LdrModulesCondensed = 6, 76 | LdrModulesReadyToInit = 7, 77 | LdrModulesInitializing = 8, 78 | LdrModulesReadyToRun = 9 79 | } LDR_DDAG_STATE; 80 | 81 | typedef struct _LDRP_CSLIST 82 | { 83 | PSINGLE_LIST_ENTRY Tail; 84 | } LDRP_CSLIST, * PLDRP_CSLIST; 85 | 86 | typedef struct _LDR_SERVICE_TAG_RECORD 87 | { 88 | struct _LDR_SERVICE_TAG_RECORD* Next; 89 | ULONG ServiceTag; 90 | } LDR_SERVICE_TAG_RECORD, * PLDR_SERVICE_TAG_RECORD; 91 | 92 | typedef struct _LDR_DDAG_NODE 93 | { 94 | LIST_ENTRY Modules; 95 | PLDR_SERVICE_TAG_RECORD ServiceTagList; 96 | ULONG LoadCount; 97 | ULONG LoadWhileUnloadingCount; 98 | ULONG LowestLink; 99 | union 100 | { 101 | LDRP_CSLIST Dependencies; 102 | SINGLE_LIST_ENTRY RemovalLink; 103 | }; 104 | LDRP_CSLIST IncomingDependencies; 105 | LDR_DDAG_STATE State; 106 | SINGLE_LIST_ENTRY CondenseLink; 107 | ULONG PreorderNumber; 108 | } LDR_DDAG_NODE, * PLDR_DDAG_NODE; 109 | 110 | typedef struct _LDR_DATA_TABLE_ENTRY 111 | { 112 | LIST_ENTRY InLoadOrderLinks; 113 | LIST_ENTRY InMemoryOrderLinks; 114 | union 115 | { 116 | LIST_ENTRY InInitializationOrderLinks; 117 | LIST_ENTRY InProgressLinks; 118 | }; 119 | PVOID DllBase; 120 | PVOID EntryPoint; 121 | ULONG SizeOfImage; 122 | UNICODE_STRING FullDllName; 123 | UNICODE_STRING BaseDllName; 124 | union 125 | { 126 | UCHAR FlagGroup[4]; 127 | ULONG Flags; 128 | struct 129 | { 130 | ULONG PackagedBinary : 1; 131 | ULONG MarkedForRemoval : 1; 132 | ULONG ImageDll : 1; 133 | ULONG LoadNotificationsSent : 1; 134 | ULONG TelemetryEntryProcessed : 1; 135 | ULONG ProcessStaticImport : 1; 136 | ULONG InLegacyLists : 1; 137 | ULONG InIndexes : 1; 138 | ULONG ShimDll : 1; 139 | ULONG InExceptionTable : 1; 140 | ULONG ReservedFlags1 : 2; 141 | ULONG LoadInProgress : 1; 142 | ULONG LoadConfigProcessed : 1; 143 | ULONG EntryProcessed : 1; 144 | ULONG ProtectDelayLoad : 1; 145 | ULONG ReservedFlags3 : 2; 146 | ULONG DontCallForThreads : 1; 147 | ULONG ProcessAttachCalled : 1; 148 | ULONG ProcessAttachFailed : 1; 149 | ULONG CorDeferredValidate : 1; 150 | ULONG CorImage : 1; 151 | ULONG DontRelocate : 1; 152 | ULONG CorILOnly : 1; 153 | ULONG ReservedFlags5 : 3; 154 | ULONG Redirected : 1; 155 | ULONG ReservedFlags6 : 2; 156 | ULONG CompatDatabaseProcessed : 1; 157 | } s; 158 | } u; 159 | USHORT ObsoleteLoadCount; 160 | USHORT TlsIndex; 161 | LIST_ENTRY HashLinks; 162 | ULONG TimeDateStamp; 163 | struct _ACTIVATION_CONTEXT* EntryPointActivationContext; 164 | PVOID Lock; 165 | PLDR_DDAG_NODE DdagNode; 166 | LIST_ENTRY NodeModuleLink; 167 | struct _LDRP_LOAD_CONTEXT* LoadContext; 168 | PVOID ParentDllBase; 169 | PVOID SwitchBackContext; 170 | RTL_BALANCED_NODE BaseAddressIndexNode; 171 | RTL_BALANCED_NODE MappingInfoIndexNode; 172 | ULONG_PTR OriginalBase; 173 | LARGE_INTEGER LoadTime; 174 | ULONG BaseNameHashValue; 175 | LDR_DLL_LOAD_REASON LoadReason; 176 | ULONG ImplicitPathOptions; 177 | ULONG ReferenceCount; 178 | ULONG DependentLoadFlags; 179 | UCHAR SigningLevel; // Since Windows 10 RS2 180 | } LDR_DATA_TABLE_ENTRY, * PLDR_DATA_TABLE_ENTRY; 181 | 182 | typedef struct _PEB_LDR_DATA 183 | { 184 | ULONG Length; 185 | BOOLEAN Initialized; 186 | HANDLE SsHandle; 187 | LIST_ENTRY InLoadOrderModuleList; 188 | LIST_ENTRY InMemoryOrderModuleList; 189 | LIST_ENTRY InInitializationOrderModuleList; 190 | PVOID EntryInProgress; 191 | BOOLEAN ShutdownInProgress; 192 | HANDLE ShutdownThreadId; 193 | } PEB_LDR_DATA, * PPEB_LDR_DATA; 194 | 195 | typedef struct _RTL_BUFFER 196 | { 197 | PUCHAR Buffer; 198 | PUCHAR StaticBuffer; 199 | SIZE_T Size; 200 | SIZE_T StaticSize; 201 | SIZE_T ReservedForAllocatedSize; // for future doubling 202 | PVOID ReservedForIMalloc; // for future pluggable growth 203 | } RTL_BUFFER, * PRTL_BUFFER; 204 | 205 | typedef struct _RTL_UNICODE_STRING_BUFFER 206 | { 207 | UNICODE_STRING String; 208 | RTL_BUFFER ByteBuffer; 209 | UCHAR MinimumStaticBufferForTerminalNul[sizeof(WCHAR)]; 210 | } RTL_UNICODE_STRING_BUFFER, * PRTL_UNICODE_STRING_BUFFER; 211 | 212 | typedef struct _RTL_DRIVE_LETTER_CURDIR 213 | { 214 | USHORT Flags; 215 | USHORT Length; 216 | ULONG TimeStamp; 217 | UNICODE_STRING DosPath; 218 | } RTL_DRIVE_LETTER_CURDIR, * PRTL_DRIVE_LETTER_CURDIR; 219 | 220 | typedef struct _CURDIR 221 | { 222 | UNICODE_STRING DosPath; 223 | HANDLE Handle; 224 | } CURDIR, * PCURDIR; 225 | 226 | typedef struct _RTL_USER_PROCESS_PARAMETERS 227 | { 228 | ULONG MaximumLength; 229 | ULONG Length; 230 | 231 | ULONG Flags; 232 | ULONG DebugFlags; 233 | 234 | HANDLE ConsoleHandle; 235 | ULONG ConsoleFlags; 236 | HANDLE StandardInput; 237 | HANDLE StandardOutput; 238 | HANDLE StandardError; 239 | 240 | CURDIR CurrentDirectory; 241 | UNICODE_STRING DllPath; 242 | UNICODE_STRING ImagePathName; 243 | UNICODE_STRING CommandLine; 244 | PWCHAR Environment; 245 | 246 | ULONG StartingX; 247 | ULONG StartingY; 248 | ULONG CountX; 249 | ULONG CountY; 250 | ULONG CountCharsX; 251 | ULONG CountCharsY; 252 | ULONG FillAttribute; 253 | 254 | ULONG WindowFlags; 255 | ULONG ShowWindowFlags; 256 | UNICODE_STRING WindowTitle; 257 | UNICODE_STRING DesktopInfo; 258 | UNICODE_STRING ShellInfo; 259 | UNICODE_STRING RuntimeData; 260 | RTL_DRIVE_LETTER_CURDIR CurrentDirectories[RTL_MAX_DRIVE_LETTERS]; 261 | 262 | ULONG_PTR EnvironmentSize; 263 | ULONG_PTR EnvironmentVersion; 264 | PVOID PackageDependencyData; 265 | ULONG ProcessGroupId; 266 | ULONG LoaderThreads; 267 | } RTL_USER_PROCESS_PARAMETERS, * PRTL_USER_PROCESS_PARAMETERS; 268 | 269 | typedef struct _PEB 270 | { 271 | BOOLEAN InheritedAddressSpace; 272 | BOOLEAN ReadImageFileExecOptions; 273 | BOOLEAN BeingDebugged; 274 | union 275 | { 276 | BOOLEAN BitField; 277 | struct 278 | { 279 | BOOLEAN ImageUsesLargePages : 1; 280 | BOOLEAN IsProtectedProcess : 1; 281 | BOOLEAN IsImageDynamicallyRelocated : 1; 282 | BOOLEAN SkipPatchingUser32Forwarders : 1; 283 | BOOLEAN IsPackagedProcess : 1; 284 | BOOLEAN IsAppContainer : 1; 285 | BOOLEAN IsProtectedProcessLight : 1; 286 | BOOLEAN IsLongPathAwareProcess : 1; 287 | } s1; 288 | } u1; 289 | 290 | HANDLE Mutant; 291 | 292 | PVOID ImageBaseAddress; 293 | PPEB_LDR_DATA Ldr; 294 | PRTL_USER_PROCESS_PARAMETERS ProcessParameters; 295 | PVOID SubSystemData; 296 | PVOID ProcessHeap; 297 | PRTL_CRITICAL_SECTION FastPebLock; 298 | PVOID AtlThunkSListPtr; 299 | PVOID IFEOKey; 300 | union 301 | { 302 | ULONG CrossProcessFlags; 303 | struct 304 | { 305 | ULONG ProcessInJob : 1; 306 | ULONG ProcessInitializing : 1; 307 | ULONG ProcessUsingVEH : 1; 308 | ULONG ProcessUsingVCH : 1; 309 | ULONG ProcessUsingFTH : 1; 310 | ULONG ProcessPreviouslyThrottled : 1; 311 | ULONG ProcessCurrentlyThrottled : 1; 312 | ULONG ReservedBits0 : 25; 313 | } s2; 314 | } u2; 315 | union 316 | { 317 | PVOID KernelCallbackTable; 318 | PVOID UserSharedInfoPtr; 319 | } u3; 320 | ULONG SystemReserved[1]; 321 | ULONG AtlThunkSListPtr32; 322 | PVOID ApiSetMap; 323 | ULONG TlsExpansionCounter; 324 | PVOID TlsBitmap; 325 | ULONG TlsBitmapBits[2]; 326 | 327 | PVOID ReadOnlySharedMemoryBase; 328 | PVOID SharedData; // HotpatchInformation 329 | PVOID* ReadOnlyStaticServerData; 330 | 331 | PVOID AnsiCodePageData; // PCPTABLEINFO 332 | PVOID OemCodePageData; // PCPTABLEINFO 333 | PVOID UnicodeCaseTableData; // PNLSTABLEINFO 334 | 335 | ULONG NumberOfProcessors; 336 | ULONG NtGlobalFlag; 337 | 338 | LARGE_INTEGER CriticalSectionTimeout; 339 | SIZE_T HeapSegmentReserve; 340 | SIZE_T HeapSegmentCommit; 341 | SIZE_T HeapDeCommitTotalFreeThreshold; 342 | SIZE_T HeapDeCommitFreeBlockThreshold; 343 | 344 | ULONG NumberOfHeaps; 345 | ULONG MaximumNumberOfHeaps; 346 | PVOID* ProcessHeaps; // PHEAP 347 | 348 | PVOID GdiSharedHandleTable; 349 | PVOID ProcessStarterHelper; 350 | ULONG GdiDCAttributeList; 351 | 352 | PRTL_CRITICAL_SECTION LoaderLock; 353 | 354 | ULONG OSMajorVersion; 355 | ULONG OSMinorVersion; 356 | USHORT OSBuildNumber; 357 | USHORT OSCSDVersion; 358 | ULONG OSPlatformId; 359 | ULONG ImageSubsystem; 360 | ULONG ImageSubsystemMajorVersion; 361 | ULONG ImageSubsystemMinorVersion; 362 | ULONG_PTR ActiveProcessAffinityMask; 363 | GDI_HANDLE_BUFFER GdiHandleBuffer; 364 | PVOID PostProcessInitRoutine; 365 | 366 | PVOID TlsExpansionBitmap; 367 | ULONG TlsExpansionBitmapBits[32]; 368 | 369 | ULONG SessionId; 370 | 371 | ULARGE_INTEGER AppCompatFlags; 372 | ULARGE_INTEGER AppCompatFlagsUser; 373 | PVOID pShimData; 374 | PVOID AppCompatInfo; // APPCOMPAT_EXE_DATA 375 | 376 | UNICODE_STRING CSDVersion; 377 | 378 | PVOID ActivationContextData; // ACTIVATION_CONTEXT_DATA 379 | PVOID ProcessAssemblyStorageMap; // ASSEMBLY_STORAGE_MAP 380 | PVOID SystemDefaultActivationContextData; // ACTIVATION_CONTEXT_DATA 381 | PVOID SystemAssemblyStorageMap; // ASSEMBLY_STORAGE_MAP 382 | 383 | SIZE_T MinimumStackCommit; 384 | 385 | PVOID* FlsCallback; 386 | LIST_ENTRY FlsListHead; 387 | PVOID FlsBitmap; 388 | ULONG FlsBitmapBits[FLS_MAXIMUM_AVAILABLE / (sizeof(ULONG) * 8)]; 389 | ULONG FlsHighIndex; 390 | 391 | PVOID WerRegistrationData; 392 | PVOID WerShipAssertPtr; 393 | PVOID pUnused; // pContextData 394 | PVOID pImageHeaderHash; 395 | union 396 | { 397 | ULONG TracingFlags; 398 | struct 399 | { 400 | ULONG HeapTracingEnabled : 1; 401 | ULONG CritSecTracingEnabled : 1; 402 | ULONG LibLoaderTracingEnabled : 1; 403 | ULONG SpareTracingBits : 29; 404 | } s3; 405 | } u4; 406 | ULONGLONG CsrServerReadOnlySharedMemoryBase; 407 | PVOID TppWorkerpListLock; 408 | LIST_ENTRY TppWorkerpList; 409 | PVOID WaitOnAddressHashTable[128]; 410 | PVOID TelemetryCoverageHeader; // REDSTONE3 411 | ULONG CloudFileFlags; 412 | } PEB, * PPEB; -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/interfaces.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace cs2_dumper { 9 | namespace interfaces { 10 | // Module: animationsystem.dll 11 | namespace animationsystem_dll { 12 | constexpr std::ptrdiff_t AnimationSystemUtils_001 = 0x58FFB8; 13 | constexpr std::ptrdiff_t AnimationSystem_001 = 0x587EE0; 14 | } 15 | // Module: client.dll 16 | namespace client_dll { 17 | constexpr std::ptrdiff_t ClientToolsInfo_001 = 0x181B770; 18 | constexpr std::ptrdiff_t EmptyWorldService001_Client = 0x17D8660; 19 | constexpr std::ptrdiff_t GameClientExports001 = 0x1818428; 20 | constexpr std::ptrdiff_t LegacyGameUI001 = 0x1838200; 21 | constexpr std::ptrdiff_t Source2Client002 = 0x1A195F0; 22 | constexpr std::ptrdiff_t Source2ClientConfig001 = 0x19BA1D0; 23 | constexpr std::ptrdiff_t Source2ClientPrediction001 = 0x18238C0; 24 | constexpr std::ptrdiff_t Source2ClientUI001 = 0x1836D30; 25 | } 26 | // Module: engine2.dll 27 | namespace engine2_dll { 28 | constexpr std::ptrdiff_t BenchmarkService001 = 0x5356C0; 29 | constexpr std::ptrdiff_t BugService001 = 0x5AC9A0; 30 | constexpr std::ptrdiff_t ClientServerEngineLoopService_001 = 0x536370; 31 | constexpr std::ptrdiff_t EngineGameUI001 = 0x533620; 32 | constexpr std::ptrdiff_t EngineServiceMgr001 = 0x5EDA50; 33 | constexpr std::ptrdiff_t GameEventSystemClientV001 = 0x5EDD70; 34 | constexpr std::ptrdiff_t GameEventSystemServerV001 = 0x5EDEC0; 35 | constexpr std::ptrdiff_t GameResourceServiceClientV001 = 0x5357C0; 36 | constexpr std::ptrdiff_t GameResourceServiceServerV001 = 0x535820; 37 | constexpr std::ptrdiff_t GameUIService_001 = 0x5ACCA0; 38 | constexpr std::ptrdiff_t HostStateMgr001 = 0x536260; 39 | constexpr std::ptrdiff_t INETSUPPORT_001 = 0x52EF00; 40 | constexpr std::ptrdiff_t InputService_001 = 0x5ACFB0; 41 | constexpr std::ptrdiff_t KeyValueCache001 = 0x536310; 42 | constexpr std::ptrdiff_t MapListService_001 = 0x5EBF50; 43 | constexpr std::ptrdiff_t NetworkClientService_001 = 0x5EC0E0; 44 | constexpr std::ptrdiff_t NetworkP2PService_001 = 0x535AB0; 45 | constexpr std::ptrdiff_t NetworkServerService_001 = 0x5EC470; 46 | constexpr std::ptrdiff_t NetworkService_001 = 0x535C00; 47 | constexpr std::ptrdiff_t RenderService_001 = 0x5EC6D0; 48 | constexpr std::ptrdiff_t ScreenshotService001 = 0x5EC990; 49 | constexpr std::ptrdiff_t SimpleEngineLoopService_001 = 0x536480; 50 | constexpr std::ptrdiff_t SoundService_001 = 0x5ECB70; 51 | constexpr std::ptrdiff_t Source2EngineToClient001 = 0x532CC0; 52 | constexpr std::ptrdiff_t Source2EngineToClientStringTable001 = 0x532D60; 53 | constexpr std::ptrdiff_t Source2EngineToServer001 = 0x532DF8; 54 | constexpr std::ptrdiff_t Source2EngineToServerStringTable001 = 0x532E20; 55 | constexpr std::ptrdiff_t SplitScreenService_001 = 0x535E40; 56 | constexpr std::ptrdiff_t StatsService_001 = 0x5ED040; 57 | constexpr std::ptrdiff_t ToolService_001 = 0x536050; 58 | constexpr std::ptrdiff_t VENGINE_GAMEUIFUNCS_VERSION005 = 0x5336B0; 59 | constexpr std::ptrdiff_t VProfService_001 = 0x536090; 60 | } 61 | // Module: filesystem_stdio.dll 62 | namespace filesystem_stdio_dll { 63 | constexpr std::ptrdiff_t VAsyncFileSystem2_001 = 0x20D5A0; 64 | constexpr std::ptrdiff_t VFileSystem017 = 0x2128A0; 65 | } 66 | // Module: host.dll 67 | namespace host_dll { 68 | constexpr std::ptrdiff_t DebugDrawQueueManager001 = 0x136FC0; 69 | constexpr std::ptrdiff_t GameModelInfo001 = 0x137000; 70 | constexpr std::ptrdiff_t GameSystem2HostHook = 0x137040; 71 | constexpr std::ptrdiff_t HostUtils001 = 0x137070; 72 | constexpr std::ptrdiff_t PredictionDiffManager001 = 0x1372C0; 73 | constexpr std::ptrdiff_t SaveRestoreDataVersion001 = 0x1373F0; 74 | constexpr std::ptrdiff_t SinglePlayerSharedMemory001 = 0x137420; 75 | constexpr std::ptrdiff_t Source2Host001 = 0x137490; 76 | } 77 | // Module: imemanager.dll 78 | namespace imemanager_dll { 79 | constexpr std::ptrdiff_t IMEManager001 = 0x2E8E0; 80 | } 81 | // Module: inputsystem.dll 82 | namespace inputsystem_dll { 83 | constexpr std::ptrdiff_t InputStackSystemVersion001 = 0x36B80; 84 | constexpr std::ptrdiff_t InputSystemVersion001 = 0x387F0; 85 | } 86 | // Module: localize.dll 87 | namespace localize_dll { 88 | constexpr std::ptrdiff_t Localize_001 = 0x3BAD0; 89 | } 90 | // Module: matchmaking.dll 91 | namespace matchmaking_dll { 92 | constexpr std::ptrdiff_t GameTypes001 = 0x1A41C0; 93 | constexpr std::ptrdiff_t MATCHFRAMEWORK_001 = 0x1AC3C0; 94 | } 95 | // Module: materialsystem2.dll 96 | namespace materialsystem2_dll { 97 | constexpr std::ptrdiff_t FontManager_001 = 0x10D320; 98 | constexpr std::ptrdiff_t MaterialUtils_001 = 0x1084F0; 99 | constexpr std::ptrdiff_t PostProcessingSystem_001 = 0x108400; 100 | constexpr std::ptrdiff_t TextLayout_001 = 0x108480; 101 | constexpr std::ptrdiff_t VMaterialSystem2_001 = 0x10C930; 102 | } 103 | // Module: meshsystem.dll 104 | namespace meshsystem_dll { 105 | constexpr std::ptrdiff_t MeshSystem001 = 0x144A30; 106 | } 107 | // Module: navsystem.dll 108 | namespace navsystem_dll { 109 | constexpr std::ptrdiff_t NavSystem001 = 0xC04E0; 110 | } 111 | // Module: networksystem.dll 112 | namespace networksystem_dll { 113 | constexpr std::ptrdiff_t FlattenedSerializersVersion001 = 0x240510; 114 | constexpr std::ptrdiff_t NetworkMessagesVersion001 = 0x272600; 115 | constexpr std::ptrdiff_t NetworkSystemVersion001 = 0x26A2A0; 116 | constexpr std::ptrdiff_t SerializedEntitiesVersion001 = 0x26A390; 117 | } 118 | // Module: panorama.dll 119 | namespace panorama_dll { 120 | constexpr std::ptrdiff_t PanoramaUIEngine001 = 0x4E2260; 121 | } 122 | // Module: panorama_text_pango.dll 123 | namespace panorama_text_pango_dll { 124 | constexpr std::ptrdiff_t PanoramaTextServices001 = 0x2B38F0; 125 | } 126 | // Module: panoramauiclient.dll 127 | namespace panoramauiclient_dll { 128 | constexpr std::ptrdiff_t PanoramaUIClient001 = 0x289860; 129 | } 130 | // Module: particles.dll 131 | namespace particles_dll { 132 | constexpr std::ptrdiff_t ParticleSystemMgr003 = 0x5BC750; 133 | } 134 | // Module: pulse_system.dll 135 | namespace pulse_system_dll { 136 | constexpr std::ptrdiff_t IPulseSystem_001 = 0x14D450; 137 | } 138 | // Module: rendersystemdx11.dll 139 | namespace rendersystemdx11_dll { 140 | constexpr std::ptrdiff_t RenderDeviceMgr001 = 0x3ED210; 141 | constexpr std::ptrdiff_t RenderUtils_001 = 0x3EDA78; 142 | constexpr std::ptrdiff_t VRenderDeviceMgrBackdoor001 = 0x3ED2A8; 143 | } 144 | // Module: resourcesystem.dll 145 | namespace resourcesystem_dll { 146 | constexpr std::ptrdiff_t ResourceSystem013 = 0x6AF10; 147 | } 148 | // Module: scenefilecache.dll 149 | namespace scenefilecache_dll { 150 | constexpr std::ptrdiff_t ResponseRulesCache001 = 0x6B110; 151 | constexpr std::ptrdiff_t SceneFileCache002 = 0x6B290; 152 | } 153 | // Module: scenesystem.dll 154 | namespace scenesystem_dll { 155 | constexpr std::ptrdiff_t RenderingPipelines_001 = 0x54DF90; 156 | constexpr std::ptrdiff_t SceneSystem_002 = 0x599980; 157 | constexpr std::ptrdiff_t SceneUtils_001 = 0x54E770; 158 | } 159 | // Module: schemasystem.dll 160 | namespace schemasystem_dll { 161 | constexpr std::ptrdiff_t SchemaSystem_001 = 0x5C710; 162 | } 163 | // Module: server.dll 164 | namespace server_dll { 165 | constexpr std::ptrdiff_t EmptyWorldService001_Server = 0x1360FC0; 166 | constexpr std::ptrdiff_t EntitySubclassUtilsV001 = 0x13134D0; 167 | constexpr std::ptrdiff_t NavGameTest001 = 0x13FF7C8; 168 | constexpr std::ptrdiff_t ServerToolsInfo_001 = 0x13B4ED8; 169 | constexpr std::ptrdiff_t Source2GameClients001 = 0x13B0340; 170 | constexpr std::ptrdiff_t Source2GameDirector001 = 0x14E46E0; 171 | constexpr std::ptrdiff_t Source2GameEntities001 = 0x13B4EA0; 172 | constexpr std::ptrdiff_t Source2Server001 = 0x13B4D10; 173 | constexpr std::ptrdiff_t Source2ServerConfig001 = 0x159F608; 174 | constexpr std::ptrdiff_t customnavsystem001 = 0x12F8D58; 175 | } 176 | // Module: soundsystem.dll 177 | namespace soundsystem_dll { 178 | constexpr std::ptrdiff_t SoundOpSystem001 = 0x3353A0; 179 | constexpr std::ptrdiff_t SoundOpSystemEdit001 = 0x335270; 180 | constexpr std::ptrdiff_t SoundSystem001 = 0x334E40; 181 | constexpr std::ptrdiff_t VMixEditTool001 = 0x48288DEA; 182 | } 183 | // Module: steamaudio.dll 184 | namespace steamaudio_dll { 185 | constexpr std::ptrdiff_t SteamAudio001 = 0x255750; 186 | } 187 | // Module: steamclient64.dll 188 | namespace steamclient64_dll { 189 | constexpr std::ptrdiff_t CLIENTENGINE_INTERFACE_VERSION005 = 0x8BD7552F; 190 | constexpr std::ptrdiff_t IVALIDATE001 = 0x153A840; 191 | constexpr std::ptrdiff_t SteamClient006 = 0x1538080; 192 | constexpr std::ptrdiff_t SteamClient007 = 0x1538088; 193 | constexpr std::ptrdiff_t SteamClient008 = 0x1538090; 194 | constexpr std::ptrdiff_t SteamClient009 = 0x1538098; 195 | constexpr std::ptrdiff_t SteamClient010 = 0x15380A0; 196 | constexpr std::ptrdiff_t SteamClient011 = 0x15380A8; 197 | constexpr std::ptrdiff_t SteamClient012 = 0x15380B0; 198 | constexpr std::ptrdiff_t SteamClient013 = 0x15380B8; 199 | constexpr std::ptrdiff_t SteamClient014 = 0x15380C0; 200 | constexpr std::ptrdiff_t SteamClient015 = 0x15380C8; 201 | constexpr std::ptrdiff_t SteamClient016 = 0x15380D0; 202 | constexpr std::ptrdiff_t SteamClient017 = 0x15380D8; 203 | constexpr std::ptrdiff_t SteamClient018 = 0x15380E0; 204 | constexpr std::ptrdiff_t SteamClient019 = 0x15380E8; 205 | constexpr std::ptrdiff_t SteamClient020 = 0x15380F0; 206 | constexpr std::ptrdiff_t SteamClient021 = 0x15380F8; 207 | constexpr std::ptrdiff_t p2pvoice002 = 0x14E6ECF; 208 | constexpr std::ptrdiff_t p2pvoicesingleton002 = 0x15140E0; 209 | } 210 | // Module: tier0.dll 211 | namespace tier0_dll { 212 | constexpr std::ptrdiff_t TestScriptMgr001 = 0x36DA30; 213 | constexpr std::ptrdiff_t VEngineCvar007 = 0x37C590; 214 | constexpr std::ptrdiff_t VProcessUtils002 = 0x36D940; 215 | constexpr std::ptrdiff_t VStringTokenSystem001 = 0x394ED0; 216 | } 217 | // Module: v8system.dll 218 | namespace v8system_dll { 219 | constexpr std::ptrdiff_t Source2V8System001 = 0x2C480; 220 | } 221 | // Module: valve_avi.dll 222 | namespace valve_avi_dll { 223 | constexpr std::ptrdiff_t VAvi001 = 0x22320; 224 | } 225 | // Module: valve_wmf.dll 226 | namespace valve_wmf_dll { 227 | constexpr std::ptrdiff_t VMediaFoundation001 = 0x1FA20; 228 | } 229 | // Module: vphysics2.dll 230 | namespace vphysics2_dll { 231 | constexpr std::ptrdiff_t VPhysics2_Handle_Interface_001 = 0x37E500; 232 | constexpr std::ptrdiff_t VPhysics2_Interface_001 = 0x37E540; 233 | } 234 | // Module: vscript.dll 235 | namespace vscript_dll { 236 | constexpr std::ptrdiff_t VScriptManager010 = 0x128600; 237 | } 238 | // Module: vstdlib_s64.dll 239 | namespace vstdlib_s64_dll { 240 | constexpr std::ptrdiff_t IVALIDATE001 = 0xA7B40; 241 | constexpr std::ptrdiff_t VEngineCvar002 = 0x65070; 242 | } 243 | // Module: worldrenderer.dll 244 | namespace worldrenderer_dll { 245 | constexpr std::ptrdiff_t WorldRendererMgr001 = 0x15FF70; 246 | } 247 | } 248 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/host.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: engine2.dll 12 | // Classes count: 44 13 | // Enums count: 4 14 | namespace engine2_dll { 15 | // Alignment: 4 16 | // Members count: 3 17 | enum class EntityDormancyType_t : uint32_t { 18 | ENTITY_NOT_DORMANT = 0x0, 19 | ENTITY_DORMANT = 0x1, 20 | ENTITY_SUSPENDED = 0x2 21 | }; 22 | // Alignment: 4 23 | // Members count: 4 24 | enum class EntityIOTargetType_t : uint32_t { 25 | ENTITY_IO_TARGET_INVALID = 0xFFFFFFFFFFFFFFFF, 26 | ENTITY_IO_TARGET_ENTITYNAME = 0x2, 27 | ENTITY_IO_TARGET_EHANDLE = 0x6, 28 | ENTITY_IO_TARGET_ENTITYNAME_OR_CLASSNAME = 0x7 29 | }; 30 | // Alignment: 4 31 | // Members count: 3 32 | enum class SpawnDebugOverrideState_t : uint32_t { 33 | SPAWN_DEBUG_OVERRIDE_NONE = 0x0, 34 | SPAWN_DEBUG_OVERRIDE_FORCE_ENABLED = 0x1, 35 | SPAWN_DEBUG_OVERRIDE_FORCE_DISABLED = 0x2 36 | }; 37 | // Alignment: 4 38 | // Members count: 5 39 | enum class SpawnDebugRestrictionOverrideState_t : uint32_t { 40 | SPAWN_DEBUG_RESTRICT_NONE = 0x0, 41 | SPAWN_DEBUG_RESTRICT_IGNORE_MANAGER_DISTANCE_REQS = 0x1, 42 | SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_DISTANCE_LOS_REQS = 0x2, 43 | SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_COOLDOWN_LIMITS = 0x4, 44 | SPAWN_DEBUG_RESTRICT_IGNORE_TARGET_COOLDOWN_LIMITS = 0x8 45 | }; 46 | // Parent: EventSimulate_t 47 | // Fields count: 0 48 | namespace EventClientPostSimulate_t { 49 | } 50 | // Parent: None 51 | // Fields count: 3 52 | namespace EventSimpleLoopFrameUpdate_t { 53 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 54 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 55 | constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float32 56 | } 57 | // Parent: EventSimulate_t 58 | // Fields count: 4 59 | namespace EventPostAdvanceTick_t { 60 | constexpr std::ptrdiff_t m_nCurrentTick = 0x30; // int32 61 | constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34; // int32 62 | constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38; // int32 63 | constexpr std::ptrdiff_t m_nTotalTicks = 0x3C; // int32 64 | } 65 | // Parent: None 66 | // Fields count: 1 67 | namespace CEntityIOOutput { 68 | constexpr std::ptrdiff_t m_Value = 0x18; // CVariantBase 69 | } 70 | // Parent: None 71 | // Fields count: 1 72 | namespace EventClientSceneSystemThreadStateChange_t { 73 | constexpr std::ptrdiff_t m_bThreadsActive = 0x0; // bool 74 | } 75 | // Parent: None 76 | // Fields count: 5 77 | namespace EventClientOutput_t { 78 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 79 | constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float32 80 | constexpr std::ptrdiff_t m_flRealTime = 0x2C; // float32 81 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x30; // float32 82 | constexpr std::ptrdiff_t m_bRenderOnly = 0x34; // bool 83 | } 84 | // Parent: EventSimulate_t 85 | // Fields count: 0 86 | namespace EventServerPostSimulate_t { 87 | } 88 | // Parent: None 89 | // Fields count: 4 90 | namespace CEntityComponentHelper { 91 | constexpr std::ptrdiff_t m_flags = 0x8; // uint32 92 | constexpr std::ptrdiff_t m_pInfo = 0x10; // EntComponentInfo_t* 93 | constexpr std::ptrdiff_t m_nPriority = 0x18; // int32 94 | constexpr std::ptrdiff_t m_pNext = 0x20; // CEntityComponentHelper* 95 | } 96 | // Parent: EventAdvanceTick_t 97 | // Fields count: 0 98 | namespace EventClientAdvanceTick_t { 99 | } 100 | // Parent: None 101 | // Fields count: 0 102 | namespace EntInput_t { 103 | } 104 | // Parent: None 105 | // Fields count: 1 106 | namespace CNetworkVarChainer { 107 | constexpr std::ptrdiff_t m_PathIndex = 0x20; // ChangeAccessorFieldPathIndex_t 108 | } 109 | // Parent: EventSimulate_t 110 | // Fields count: 0 111 | namespace EventClientSimulate_t { 112 | } 113 | // Parent: None 114 | // Fields count: 5 115 | namespace EventClientPostOutput_t { 116 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 117 | constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float64 118 | constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30; // float32 119 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x34; // float32 120 | constexpr std::ptrdiff_t m_bRenderOnly = 0x38; // bool 121 | } 122 | // Parent: None 123 | // Fields count: 2 124 | namespace EventClientPollInput_t { 125 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 126 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 127 | } 128 | // Parent: None 129 | // Fields count: 1 130 | namespace EventPreDataUpdate_t { 131 | constexpr std::ptrdiff_t m_nCount = 0x0; // int32 132 | } 133 | // Parent: None 134 | // Fields count: 3 135 | namespace EventClientProcessGameInput_t { 136 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 137 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 138 | constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float32 139 | } 140 | // Parent: None 141 | // Fields count: 1 142 | namespace EventFrameBoundary_t { 143 | constexpr std::ptrdiff_t m_flFrameTime = 0x0; // float32 144 | } 145 | // Parent: None 146 | // Fields count: 1 147 | namespace EventAppShutdown_t { 148 | constexpr std::ptrdiff_t m_nDummy0 = 0x0; // int32 149 | } 150 | // Parent: EventSimulate_t 151 | // Fields count: 0 152 | namespace EventServerSimulate_t { 153 | } 154 | // Parent: EventPostAdvanceTick_t 155 | // Fields count: 0 156 | namespace EventServerPostAdvanceTick_t { 157 | } 158 | // Parent: None 159 | // Fields count: 1 160 | namespace EventProfileStorageAvailable_t { 161 | constexpr std::ptrdiff_t m_nSplitScreenSlot = 0x0; // CSplitScreenSlot 162 | } 163 | // Parent: None 164 | // Fields count: 1 165 | namespace EventPostDataUpdate_t { 166 | constexpr std::ptrdiff_t m_nCount = 0x0; // int32 167 | } 168 | // Parent: EventSimulate_t 169 | // Fields count: 0 170 | namespace EventClientPreSimulate_t { 171 | } 172 | // Parent: EventSimulate_t 173 | // Fields count: 0 174 | namespace EventClientPauseSimulate_t { 175 | } 176 | // Parent: None 177 | // Fields count: 0 178 | namespace EventClientProcessNetworking_t { 179 | } 180 | // Parent: EventSimulate_t 181 | // Fields count: 4 182 | namespace EventAdvanceTick_t { 183 | constexpr std::ptrdiff_t m_nCurrentTick = 0x30; // int32 184 | constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34; // int32 185 | constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38; // int32 186 | constexpr std::ptrdiff_t m_nTotalTicks = 0x3C; // int32 187 | } 188 | // Parent: None 189 | // Fields count: 0 190 | namespace EventSplitScreenStateChanged_t { 191 | } 192 | // Parent: EventPostAdvanceTick_t 193 | // Fields count: 0 194 | namespace EventClientPostAdvanceTick_t { 195 | } 196 | // Parent: None 197 | // Fields count: 0 198 | namespace CVariantDefaultAllocator { 199 | } 200 | // Parent: None 201 | // Fields count: 0 202 | namespace EventModInitialized_t { 203 | } 204 | // Parent: None 205 | // Fields count: 6 206 | namespace EventClientPreOutput_t { 207 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 208 | constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float64 209 | constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30; // float64 210 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x38; // float64 211 | constexpr std::ptrdiff_t m_flRealTime = 0x40; // float32 212 | constexpr std::ptrdiff_t m_bRenderOnly = 0x44; // bool 213 | } 214 | // Parent: None 215 | // Fields count: 4 216 | namespace EventClientFrameSimulate_t { 217 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 218 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 219 | constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float32 220 | constexpr std::ptrdiff_t m_bScheduleSendTickPacket = 0x30; // bool 221 | } 222 | // Parent: EventAdvanceTick_t 223 | // Fields count: 0 224 | namespace EventServerAdvanceTick_t { 225 | } 226 | // Parent: None 227 | // Fields count: 8 228 | namespace EventSetTime_t { 229 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 230 | constexpr std::ptrdiff_t m_nClientOutputFrames = 0x28; // int32 231 | constexpr std::ptrdiff_t m_flRealTime = 0x30; // float64 232 | constexpr std::ptrdiff_t m_flRenderTime = 0x38; // float64 233 | constexpr std::ptrdiff_t m_flRenderFrameTime = 0x40; // float64 234 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x48; // float64 235 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnscaled = 0x50; // float64 236 | constexpr std::ptrdiff_t m_flTickRemainder = 0x58; // float64 237 | } 238 | // Parent: None 239 | // Fields count: 0 240 | namespace EntOutput_t { 241 | } 242 | // Parent: None 243 | // Fields count: 3 244 | namespace EventSimulate_t { 245 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 246 | constexpr std::ptrdiff_t m_bFirstTick = 0x28; // bool 247 | constexpr std::ptrdiff_t m_bLastTick = 0x29; // bool 248 | } 249 | // Parent: None 250 | // Fields count: 0 251 | namespace EventClientAdvanceNonRenderedFrame_t { 252 | } 253 | // Parent: EventSimulate_t 254 | // Fields count: 0 255 | namespace EventServerProcessNetworking_t { 256 | } 257 | // Parent: None 258 | // Fields count: 0 259 | namespace CEmptyEntityInstance { 260 | } 261 | // Parent: None 262 | // Fields count: 7 263 | namespace EntComponentInfo_t { 264 | constexpr std::ptrdiff_t m_pName = 0x0; // char* 265 | constexpr std::ptrdiff_t m_pCPPClassname = 0x8; // char* 266 | constexpr std::ptrdiff_t m_pNetworkDataReferencedDescription = 0x10; // char* 267 | constexpr std::ptrdiff_t m_pNetworkDataReferencedPtrPropDescription = 0x18; // char* 268 | constexpr std::ptrdiff_t m_nRuntimeIndex = 0x20; // int32 269 | constexpr std::ptrdiff_t m_nFlags = 0x24; // uint32 270 | constexpr std::ptrdiff_t m_pBaseClassComponentHelper = 0x60; // CEntityComponentHelper* 271 | } 272 | // Parent: None 273 | // Fields count: 4 274 | namespace EngineLoopState_t { 275 | constexpr std::ptrdiff_t m_nPlatWindowWidth = 0x18; // int32 276 | constexpr std::ptrdiff_t m_nPlatWindowHeight = 0x1C; // int32 277 | constexpr std::ptrdiff_t m_nRenderWidth = 0x20; // int32 278 | constexpr std::ptrdiff_t m_nRenderHeight = 0x24; // int32 279 | } 280 | // Parent: None 281 | // Fields count: 1 282 | namespace EventClientPollNetworking_t { 283 | constexpr std::ptrdiff_t m_nTickCount = 0x0; // int32 284 | } 285 | // Parent: None 286 | // Fields count: 4 287 | namespace EventClientProcessInput_t { 288 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 289 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 290 | constexpr std::ptrdiff_t m_flTickInterval = 0x2C; // float32 291 | constexpr std::ptrdiff_t m_flTickStartTime = 0x30; // float64 292 | } 293 | // Parent: EventSimulate_t 294 | // Fields count: 0 295 | namespace EventServerPollNetworking_t { 296 | } 297 | } 298 | } 299 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/engine2.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: engine2.dll 12 | // Classes count: 44 13 | // Enums count: 4 14 | namespace engine2_dll { 15 | // Alignment: 4 16 | // Members count: 3 17 | enum class EntityDormancyType_t : uint32_t { 18 | ENTITY_NOT_DORMANT = 0x0, 19 | ENTITY_DORMANT = 0x1, 20 | ENTITY_SUSPENDED = 0x2 21 | }; 22 | // Alignment: 4 23 | // Members count: 4 24 | enum class EntityIOTargetType_t : uint32_t { 25 | ENTITY_IO_TARGET_INVALID = 0xFFFFFFFFFFFFFFFF, 26 | ENTITY_IO_TARGET_ENTITYNAME = 0x2, 27 | ENTITY_IO_TARGET_EHANDLE = 0x6, 28 | ENTITY_IO_TARGET_ENTITYNAME_OR_CLASSNAME = 0x7 29 | }; 30 | // Alignment: 4 31 | // Members count: 3 32 | enum class SpawnDebugOverrideState_t : uint32_t { 33 | SPAWN_DEBUG_OVERRIDE_NONE = 0x0, 34 | SPAWN_DEBUG_OVERRIDE_FORCE_ENABLED = 0x1, 35 | SPAWN_DEBUG_OVERRIDE_FORCE_DISABLED = 0x2 36 | }; 37 | // Alignment: 4 38 | // Members count: 5 39 | enum class SpawnDebugRestrictionOverrideState_t : uint32_t { 40 | SPAWN_DEBUG_RESTRICT_NONE = 0x0, 41 | SPAWN_DEBUG_RESTRICT_IGNORE_MANAGER_DISTANCE_REQS = 0x1, 42 | SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_DISTANCE_LOS_REQS = 0x2, 43 | SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_COOLDOWN_LIMITS = 0x4, 44 | SPAWN_DEBUG_RESTRICT_IGNORE_TARGET_COOLDOWN_LIMITS = 0x8 45 | }; 46 | // Parent: EventSimulate_t 47 | // Fields count: 0 48 | namespace EventClientPostSimulate_t { 49 | } 50 | // Parent: None 51 | // Fields count: 3 52 | namespace EventSimpleLoopFrameUpdate_t { 53 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 54 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 55 | constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float32 56 | } 57 | // Parent: EventSimulate_t 58 | // Fields count: 4 59 | namespace EventPostAdvanceTick_t { 60 | constexpr std::ptrdiff_t m_nCurrentTick = 0x30; // int32 61 | constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34; // int32 62 | constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38; // int32 63 | constexpr std::ptrdiff_t m_nTotalTicks = 0x3C; // int32 64 | } 65 | // Parent: None 66 | // Fields count: 1 67 | namespace CEntityIOOutput { 68 | constexpr std::ptrdiff_t m_Value = 0x18; // CVariantBase 69 | } 70 | // Parent: None 71 | // Fields count: 1 72 | namespace EventClientSceneSystemThreadStateChange_t { 73 | constexpr std::ptrdiff_t m_bThreadsActive = 0x0; // bool 74 | } 75 | // Parent: None 76 | // Fields count: 5 77 | namespace EventClientOutput_t { 78 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 79 | constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float32 80 | constexpr std::ptrdiff_t m_flRealTime = 0x2C; // float32 81 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x30; // float32 82 | constexpr std::ptrdiff_t m_bRenderOnly = 0x34; // bool 83 | } 84 | // Parent: EventSimulate_t 85 | // Fields count: 0 86 | namespace EventServerPostSimulate_t { 87 | } 88 | // Parent: None 89 | // Fields count: 4 90 | namespace CEntityComponentHelper { 91 | constexpr std::ptrdiff_t m_flags = 0x8; // uint32 92 | constexpr std::ptrdiff_t m_pInfo = 0x10; // EntComponentInfo_t* 93 | constexpr std::ptrdiff_t m_nPriority = 0x18; // int32 94 | constexpr std::ptrdiff_t m_pNext = 0x20; // CEntityComponentHelper* 95 | } 96 | // Parent: EventAdvanceTick_t 97 | // Fields count: 0 98 | namespace EventClientAdvanceTick_t { 99 | } 100 | // Parent: None 101 | // Fields count: 0 102 | namespace EntInput_t { 103 | } 104 | // Parent: None 105 | // Fields count: 1 106 | namespace CNetworkVarChainer { 107 | constexpr std::ptrdiff_t m_PathIndex = 0x20; // ChangeAccessorFieldPathIndex_t 108 | } 109 | // Parent: EventSimulate_t 110 | // Fields count: 0 111 | namespace EventClientSimulate_t { 112 | } 113 | // Parent: None 114 | // Fields count: 5 115 | namespace EventClientPostOutput_t { 116 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 117 | constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float64 118 | constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30; // float32 119 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x34; // float32 120 | constexpr std::ptrdiff_t m_bRenderOnly = 0x38; // bool 121 | } 122 | // Parent: None 123 | // Fields count: 2 124 | namespace EventClientPollInput_t { 125 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 126 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 127 | } 128 | // Parent: None 129 | // Fields count: 1 130 | namespace EventPreDataUpdate_t { 131 | constexpr std::ptrdiff_t m_nCount = 0x0; // int32 132 | } 133 | // Parent: None 134 | // Fields count: 3 135 | namespace EventClientProcessGameInput_t { 136 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 137 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 138 | constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float32 139 | } 140 | // Parent: None 141 | // Fields count: 1 142 | namespace EventFrameBoundary_t { 143 | constexpr std::ptrdiff_t m_flFrameTime = 0x0; // float32 144 | } 145 | // Parent: None 146 | // Fields count: 1 147 | namespace EventAppShutdown_t { 148 | constexpr std::ptrdiff_t m_nDummy0 = 0x0; // int32 149 | } 150 | // Parent: EventSimulate_t 151 | // Fields count: 0 152 | namespace EventServerSimulate_t { 153 | } 154 | // Parent: EventPostAdvanceTick_t 155 | // Fields count: 0 156 | namespace EventServerPostAdvanceTick_t { 157 | } 158 | // Parent: None 159 | // Fields count: 1 160 | namespace EventProfileStorageAvailable_t { 161 | constexpr std::ptrdiff_t m_nSplitScreenSlot = 0x0; // CSplitScreenSlot 162 | } 163 | // Parent: None 164 | // Fields count: 1 165 | namespace EventPostDataUpdate_t { 166 | constexpr std::ptrdiff_t m_nCount = 0x0; // int32 167 | } 168 | // Parent: EventSimulate_t 169 | // Fields count: 0 170 | namespace EventClientPreSimulate_t { 171 | } 172 | // Parent: EventSimulate_t 173 | // Fields count: 0 174 | namespace EventClientPauseSimulate_t { 175 | } 176 | // Parent: None 177 | // Fields count: 0 178 | namespace EventClientProcessNetworking_t { 179 | } 180 | // Parent: EventSimulate_t 181 | // Fields count: 4 182 | namespace EventAdvanceTick_t { 183 | constexpr std::ptrdiff_t m_nCurrentTick = 0x30; // int32 184 | constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34; // int32 185 | constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38; // int32 186 | constexpr std::ptrdiff_t m_nTotalTicks = 0x3C; // int32 187 | } 188 | // Parent: None 189 | // Fields count: 0 190 | namespace EventSplitScreenStateChanged_t { 191 | } 192 | // Parent: EventPostAdvanceTick_t 193 | // Fields count: 0 194 | namespace EventClientPostAdvanceTick_t { 195 | } 196 | // Parent: None 197 | // Fields count: 0 198 | namespace CVariantDefaultAllocator { 199 | } 200 | // Parent: None 201 | // Fields count: 0 202 | namespace EventModInitialized_t { 203 | } 204 | // Parent: None 205 | // Fields count: 6 206 | namespace EventClientPreOutput_t { 207 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 208 | constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float64 209 | constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30; // float64 210 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x38; // float64 211 | constexpr std::ptrdiff_t m_flRealTime = 0x40; // float32 212 | constexpr std::ptrdiff_t m_bRenderOnly = 0x44; // bool 213 | } 214 | // Parent: None 215 | // Fields count: 4 216 | namespace EventClientFrameSimulate_t { 217 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 218 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 219 | constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float32 220 | constexpr std::ptrdiff_t m_bScheduleSendTickPacket = 0x30; // bool 221 | } 222 | // Parent: EventAdvanceTick_t 223 | // Fields count: 0 224 | namespace EventServerAdvanceTick_t { 225 | } 226 | // Parent: None 227 | // Fields count: 8 228 | namespace EventSetTime_t { 229 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 230 | constexpr std::ptrdiff_t m_nClientOutputFrames = 0x28; // int32 231 | constexpr std::ptrdiff_t m_flRealTime = 0x30; // float64 232 | constexpr std::ptrdiff_t m_flRenderTime = 0x38; // float64 233 | constexpr std::ptrdiff_t m_flRenderFrameTime = 0x40; // float64 234 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x48; // float64 235 | constexpr std::ptrdiff_t m_flRenderFrameTimeUnscaled = 0x50; // float64 236 | constexpr std::ptrdiff_t m_flTickRemainder = 0x58; // float64 237 | } 238 | // Parent: None 239 | // Fields count: 0 240 | namespace EntOutput_t { 241 | } 242 | // Parent: None 243 | // Fields count: 3 244 | namespace EventSimulate_t { 245 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 246 | constexpr std::ptrdiff_t m_bFirstTick = 0x28; // bool 247 | constexpr std::ptrdiff_t m_bLastTick = 0x29; // bool 248 | } 249 | // Parent: None 250 | // Fields count: 0 251 | namespace EventClientAdvanceNonRenderedFrame_t { 252 | } 253 | // Parent: EventSimulate_t 254 | // Fields count: 0 255 | namespace EventServerProcessNetworking_t { 256 | } 257 | // Parent: None 258 | // Fields count: 0 259 | namespace CEmptyEntityInstance { 260 | } 261 | // Parent: None 262 | // Fields count: 7 263 | namespace EntComponentInfo_t { 264 | constexpr std::ptrdiff_t m_pName = 0x0; // char* 265 | constexpr std::ptrdiff_t m_pCPPClassname = 0x8; // char* 266 | constexpr std::ptrdiff_t m_pNetworkDataReferencedDescription = 0x10; // char* 267 | constexpr std::ptrdiff_t m_pNetworkDataReferencedPtrPropDescription = 0x18; // char* 268 | constexpr std::ptrdiff_t m_nRuntimeIndex = 0x20; // int32 269 | constexpr std::ptrdiff_t m_nFlags = 0x24; // uint32 270 | constexpr std::ptrdiff_t m_pBaseClassComponentHelper = 0x60; // CEntityComponentHelper* 271 | } 272 | // Parent: None 273 | // Fields count: 4 274 | namespace EngineLoopState_t { 275 | constexpr std::ptrdiff_t m_nPlatWindowWidth = 0x18; // int32 276 | constexpr std::ptrdiff_t m_nPlatWindowHeight = 0x1C; // int32 277 | constexpr std::ptrdiff_t m_nRenderWidth = 0x20; // int32 278 | constexpr std::ptrdiff_t m_nRenderHeight = 0x24; // int32 279 | } 280 | // Parent: None 281 | // Fields count: 1 282 | namespace EventClientPollNetworking_t { 283 | constexpr std::ptrdiff_t m_nTickCount = 0x0; // int32 284 | } 285 | // Parent: None 286 | // Fields count: 4 287 | namespace EventClientProcessInput_t { 288 | constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t 289 | constexpr std::ptrdiff_t m_flRealTime = 0x28; // float32 290 | constexpr std::ptrdiff_t m_flTickInterval = 0x2C; // float32 291 | constexpr std::ptrdiff_t m_flTickStartTime = 0x30; // float64 292 | } 293 | // Parent: EventSimulate_t 294 | // Fields count: 0 295 | namespace EventServerPollNetworking_t { 296 | } 297 | } 298 | } 299 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/resourcesystem.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: resourcesystem.dll 12 | // Classes count: 58 13 | // Enums count: 2 14 | namespace resourcesystem_dll { 15 | // Alignment: 1 16 | // Members count: 9 17 | enum class FuseVariableType_t : uint8_t { 18 | INVALID = 0x0, 19 | BOOL = 0x1, 20 | INT8 = 0x2, 21 | INT16 = 0x3, 22 | INT32 = 0x4, 23 | UINT8 = 0x5, 24 | UINT16 = 0x6, 25 | UINT32 = 0x7, 26 | FLOAT32 = 0x8 27 | }; 28 | // Alignment: 1 29 | // Members count: 2 30 | enum class FuseVariableAccess_t : uint8_t { 31 | WRITABLE = 0x0, 32 | READ_ONLY = 0x1 33 | }; 34 | // Parent: None 35 | // Fields count: 0 36 | // 37 | // Metadata: 38 | // MResourceTypeForInfoType 39 | namespace InfoForResourceTypeCResponseRulesList { 40 | } 41 | // Parent: None 42 | // Fields count: 0 43 | // 44 | // Metadata: 45 | // MResourceTypeForInfoType 46 | namespace InfoForResourceTypeCDotaItemDefinitionResource { 47 | } 48 | // Parent: None 49 | // Fields count: 0 50 | // 51 | // Metadata: 52 | // MResourceTypeForInfoType 53 | namespace InfoForResourceTypeCMorphSetData { 54 | } 55 | // Parent: None 56 | // Fields count: 0 57 | // 58 | // Metadata: 59 | // MResourceTypeForInfoType 60 | namespace InfoForResourceTypeCChoreoSceneFileData { 61 | } 62 | // Parent: None 63 | // Fields count: 0 64 | // 65 | // Metadata: 66 | // MResourceTypeForInfoType 67 | namespace InfoForResourceTypeCVSoundStackScriptList { 68 | } 69 | // Parent: None 70 | // Fields count: 2 71 | namespace PackedAABB_t { 72 | constexpr std::ptrdiff_t m_nPackedMin = 0x0; // uint32 73 | constexpr std::ptrdiff_t m_nPackedMax = 0x4; // uint32 74 | } 75 | // Parent: None 76 | // Fields count: 0 77 | // 78 | // Metadata: 79 | // MResourceTypeForInfoType 80 | namespace InfoForResourceTypeCVPhysXSurfacePropertiesList { 81 | } 82 | // Parent: None 83 | // Fields count: 0 84 | // 85 | // Metadata: 86 | // MResourceTypeForInfoType 87 | namespace InfoForResourceTypeManifestTestResource_t { 88 | } 89 | // Parent: None 90 | // Fields count: 3 91 | // 92 | // Metadata: 93 | // MGetKV3ClassDefaults 94 | namespace ConstantInfo_t { 95 | constexpr std::ptrdiff_t m_name = 0x0; // CUtlString 96 | constexpr std::ptrdiff_t m_nameToken = 0x8; // CUtlStringToken 97 | constexpr std::ptrdiff_t m_flValue = 0xC; // float32 98 | } 99 | // Parent: None 100 | // Fields count: 1 101 | namespace FuseFunctionIndex_t { 102 | constexpr std::ptrdiff_t m_Value = 0x0; // uint16 103 | } 104 | // Parent: None 105 | // Fields count: 0 106 | // 107 | // Metadata: 108 | // MResourceTypeForInfoType 109 | namespace InfoForResourceTypeCGcExportableExternalData { 110 | } 111 | // Parent: None 112 | // Fields count: 0 113 | // 114 | // Metadata: 115 | // MResourceTypeForInfoType 116 | namespace InfoForResourceTypeIAnimGraphModelBinding { 117 | } 118 | // Parent: None 119 | // Fields count: 0 120 | // 121 | // Metadata: 122 | // MResourceTypeForInfoType 123 | namespace InfoForResourceTypeCJavaScriptResource { 124 | } 125 | // Parent: None 126 | // Fields count: 6 127 | // 128 | // Metadata: 129 | // MGetKV3ClassDefaults 130 | namespace CFuseSymbolTable { 131 | constexpr std::ptrdiff_t m_constants = 0x0; // CUtlVector 132 | constexpr std::ptrdiff_t m_variables = 0x18; // CUtlVector 133 | constexpr std::ptrdiff_t m_functions = 0x30; // CUtlVector 134 | constexpr std::ptrdiff_t m_constantMap = 0x48; // CUtlHashtable 135 | constexpr std::ptrdiff_t m_variableMap = 0x68; // CUtlHashtable 136 | constexpr std::ptrdiff_t m_functionMap = 0x88; // CUtlHashtable 137 | } 138 | // Parent: None 139 | // Fields count: 0 140 | // 141 | // Metadata: 142 | // MResourceTypeForInfoType 143 | namespace InfoForResourceTypeCRenderMesh { 144 | } 145 | // Parent: None 146 | // Fields count: 0 147 | // 148 | // Metadata: 149 | // MResourceTypeForInfoType 150 | namespace InfoForResourceTypeCVoxelVisibility { 151 | } 152 | // Parent: None 153 | // Fields count: 1 154 | // 155 | // Metadata: 156 | // MGetKV3ClassDefaults 157 | namespace TestResource_t { 158 | constexpr std::ptrdiff_t m_name = 0x0; // CUtlString 159 | } 160 | // Parent: None 161 | // Fields count: 0 162 | // 163 | // Metadata: 164 | // MResourceTypeForInfoType 165 | namespace InfoForResourceTypeCPhysAggregateData { 166 | } 167 | // Parent: None 168 | // Fields count: 0 169 | // 170 | // Metadata: 171 | // MResourceTypeForInfoType 172 | namespace InfoForResourceTypeCNmClip { 173 | } 174 | // Parent: None 175 | // Fields count: 0 176 | // 177 | // Metadata: 178 | // MResourceTypeForInfoType 179 | namespace InfoForResourceTypeWorld_t { 180 | } 181 | // Parent: None 182 | // Fields count: 0 183 | // 184 | // Metadata: 185 | // MResourceTypeForInfoType 186 | namespace InfoForResourceTypeProceduralTestResource_t { 187 | } 188 | // Parent: None 189 | // Fields count: 2 190 | namespace AABB_t { 191 | constexpr std::ptrdiff_t m_vMinBounds = 0x0; // Vector 192 | constexpr std::ptrdiff_t m_vMaxBounds = 0xC; // Vector 193 | } 194 | // Parent: None 195 | // Fields count: 0 196 | // 197 | // Metadata: 198 | // MResourceTypeForInfoType 199 | namespace InfoForResourceTypeCPostProcessingResource { 200 | } 201 | // Parent: None 202 | // Fields count: 6 203 | // 204 | // Metadata: 205 | // MGetKV3ClassDefaults 206 | namespace VariableInfo_t { 207 | constexpr std::ptrdiff_t m_name = 0x0; // CUtlString 208 | constexpr std::ptrdiff_t m_nameToken = 0x8; // CUtlStringToken 209 | constexpr std::ptrdiff_t m_nIndex = 0xC; // FuseVariableIndex_t 210 | constexpr std::ptrdiff_t m_nNumComponents = 0xE; // uint8 211 | constexpr std::ptrdiff_t m_eVarType = 0xF; // FuseVariableType_t 212 | constexpr std::ptrdiff_t m_eAccess = 0x10; // FuseVariableAccess_t 213 | } 214 | // Parent: None 215 | // Fields count: 0 216 | // 217 | // Metadata: 218 | // MResourceTypeForInfoType 219 | namespace InfoForResourceTypeIParticleSnapshot { 220 | } 221 | // Parent: None 222 | // Fields count: 4 223 | namespace FourQuaternions { 224 | constexpr std::ptrdiff_t x = 0x0; // fltx4 225 | constexpr std::ptrdiff_t y = 0x10; // fltx4 226 | constexpr std::ptrdiff_t z = 0x20; // fltx4 227 | constexpr std::ptrdiff_t w = 0x30; // fltx4 228 | } 229 | // Parent: None 230 | // Fields count: 0 231 | // 232 | // Metadata: 233 | // MResourceTypeForInfoType 234 | namespace InfoForResourceTypeCPanoramaLayout { 235 | } 236 | // Parent: None 237 | // Fields count: 0 238 | // 239 | // Metadata: 240 | // MResourceTypeForInfoType 241 | namespace InfoForResourceTypeCTypeScriptResource { 242 | } 243 | // Parent: None 244 | // Fields count: 0 245 | // 246 | // Metadata: 247 | // MResourceTypeForInfoType 248 | namespace InfoForResourceTypeCNmSkeleton { 249 | } 250 | // Parent: None 251 | // Fields count: 0 252 | // 253 | // Metadata: 254 | // MResourceTypeForInfoType 255 | namespace InfoForResourceTypeTestResource_t { 256 | } 257 | // Parent: None 258 | // Fields count: 0 259 | // 260 | // Metadata: 261 | // MResourceTypeForInfoType 262 | namespace InfoForResourceTypeCAnimationGroup { 263 | } 264 | // Parent: None 265 | // Fields count: 0 266 | // 267 | // Metadata: 268 | // MResourceTypeForInfoType 269 | namespace InfoForResourceTypeCVSoundEventScriptList { 270 | } 271 | // Parent: None 272 | // Fields count: 0 273 | // 274 | // Metadata: 275 | // MResourceTypeForInfoType 276 | namespace InfoForResourceTypeCVoiceContainerBase { 277 | } 278 | // Parent: None 279 | // Fields count: 0 280 | // 281 | // Metadata: 282 | // MResourceTypeForInfoType 283 | namespace InfoForResourceTypeCPanoramaStyle { 284 | } 285 | // Parent: None 286 | // Fields count: 0 287 | // 288 | // Metadata: 289 | // MResourceTypeForInfoType 290 | namespace InfoForResourceTypeCWorldNode { 291 | } 292 | // Parent: None 293 | // Fields count: 0 294 | // 295 | // Metadata: 296 | // MResourceTypeForInfoType 297 | namespace InfoForResourceTypeCNmGraphVariation { 298 | } 299 | // Parent: None 300 | // Fields count: 0 301 | // 302 | // Metadata: 303 | // MResourceTypeForInfoType 304 | namespace InfoForResourceTypeCCSGOEconItem { 305 | } 306 | // Parent: None 307 | // Fields count: 0 308 | // 309 | // Metadata: 310 | // MResourceTypeForInfoType 311 | namespace InfoForResourceTypeCNmGraphDefinition { 312 | } 313 | // Parent: None 314 | // Fields count: 0 315 | // 316 | // Metadata: 317 | // MResourceTypeForInfoType 318 | namespace InfoForResourceTypeCSmartProp { 319 | } 320 | // Parent: None 321 | // Fields count: 4 322 | // 323 | // Metadata: 324 | // MGetKV3ClassDefaults 325 | namespace CFuseProgram { 326 | constexpr std::ptrdiff_t m_programBuffer = 0x0; // CUtlVector 327 | constexpr std::ptrdiff_t m_variablesRead = 0x18; // CUtlVector 328 | constexpr std::ptrdiff_t m_variablesWritten = 0x30; // CUtlVector 329 | constexpr std::ptrdiff_t m_nMaxTempVarsUsed = 0x48; // int32 330 | } 331 | // Parent: None 332 | // Fields count: 0 333 | // 334 | // Metadata: 335 | // MResourceTypeForInfoType 336 | namespace InfoForResourceTypeCCompositeMaterialKit { 337 | } 338 | // Parent: None 339 | // Fields count: 0 340 | // 341 | // Metadata: 342 | // MResourceTypeForInfoType 343 | namespace InfoForResourceTypeCVMixListResource { 344 | } 345 | // Parent: None 346 | // Fields count: 0 347 | // 348 | // Metadata: 349 | // MResourceTypeForInfoType 350 | namespace InfoForResourceTypeCAnimData { 351 | } 352 | // Parent: None 353 | // Fields count: 0 354 | // 355 | // Metadata: 356 | // MResourceTypeForInfoType 357 | namespace InfoForResourceTypeIMaterial2 { 358 | } 359 | // Parent: None 360 | // Fields count: 0 361 | // 362 | // Metadata: 363 | // MResourceTypeForInfoType 364 | namespace InfoForResourceTypeIVectorGraphic { 365 | } 366 | // Parent: None 367 | // Fields count: 0 368 | // 369 | // Metadata: 370 | // MResourceTypeForInfoType 371 | namespace InfoForResourceTypeCPanoramaDynamicImages { 372 | } 373 | // Parent: None 374 | // Fields count: 0 375 | // 376 | // Metadata: 377 | // MResourceTypeForInfoType 378 | namespace InfoForResourceTypeIPulseGraphDef { 379 | } 380 | // Parent: None 381 | // Fields count: 5 382 | // 383 | // Metadata: 384 | // MGetKV3ClassDefaults 385 | namespace FunctionInfo_t { 386 | constexpr std::ptrdiff_t m_name = 0x8; // CUtlString 387 | constexpr std::ptrdiff_t m_nameToken = 0x10; // CUtlStringToken 388 | constexpr std::ptrdiff_t m_nParamCount = 0x14; // int32 389 | constexpr std::ptrdiff_t m_nIndex = 0x18; // FuseFunctionIndex_t 390 | constexpr std::ptrdiff_t m_bIsPure = 0x1A; // bool 391 | } 392 | // Parent: None 393 | // Fields count: 0 394 | // 395 | // Metadata: 396 | // MResourceTypeForInfoType 397 | namespace InfoForResourceTypeCVDataResource { 398 | } 399 | // Parent: None 400 | // Fields count: 0 401 | // 402 | // Metadata: 403 | // MResourceTypeForInfoType 404 | namespace InfoForResourceTypeCModel { 405 | } 406 | // Parent: None 407 | // Fields count: 0 408 | // 409 | // Metadata: 410 | // MResourceTypeForInfoType 411 | namespace InfoForResourceTypeCDOTANovelsList { 412 | } 413 | // Parent: None 414 | // Fields count: 0 415 | // 416 | // Metadata: 417 | // MResourceTypeForInfoType 418 | namespace InfoForResourceTypeCTextureBase { 419 | } 420 | // Parent: None 421 | // Fields count: 1 422 | namespace FuseVariableIndex_t { 423 | constexpr std::ptrdiff_t m_Value = 0x0; // uint16 424 | } 425 | // Parent: None 426 | // Fields count: 0 427 | // 428 | // Metadata: 429 | // MResourceTypeForInfoType 430 | namespace InfoForResourceTypeIParticleSystemDefinition { 431 | } 432 | // Parent: None 433 | // Fields count: 0 434 | // 435 | // Metadata: 436 | // MResourceTypeForInfoType 437 | namespace InfoForResourceTypeCSequenceGroupData { 438 | } 439 | // Parent: None 440 | // Fields count: 2 441 | // 442 | // Metadata: 443 | // MGetKV3ClassDefaults 444 | namespace ManifestTestResource_t { 445 | constexpr std::ptrdiff_t m_name = 0x0; // CUtlString 446 | constexpr std::ptrdiff_t m_child = 0x8; // CStrongHandle 447 | } 448 | // Parent: None 449 | // Fields count: 0 450 | // 451 | // Metadata: 452 | // MResourceTypeForInfoType 453 | namespace InfoForResourceTypeCEntityLump { 454 | } 455 | // Parent: None 456 | // Fields count: 0 457 | // 458 | // Metadata: 459 | // MResourceTypeForInfoType 460 | namespace InfoForResourceTypeCDOTAPatchNotesList { 461 | } 462 | } 463 | } 464 | } -------------------------------------------------------------------------------- /CS2_Internal_Trainer/SDK/CS2_Dumper/worldrenderer.dll.hpp: -------------------------------------------------------------------------------- 1 | // Generated using https://github.com/a2x/cs2-dumper 2 | // 2024-07-02 22:14:16.333089500 UTC 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace cs2_dumper { 10 | namespace schemas { 11 | // Module: worldrenderer.dll 12 | // Classes count: 23 13 | // Enums count: 1 14 | namespace worldrenderer_dll { 15 | // Alignment: 4 16 | // Members count: 13 17 | enum class ObjectTypeFlags_t : uint32_t { 18 | OBJECT_TYPE_NONE = 0x0, 19 | OBJECT_TYPE_MODEL = 0x8, 20 | OBJECT_TYPE_BLOCK_LIGHT = 0x10, 21 | OBJECT_TYPE_NO_SHADOWS = 0x20, 22 | OBJECT_TYPE_WORLDSPACE_TEXURE_BLEND = 0x40, 23 | OBJECT_TYPE_DISABLED_IN_LOW_QUALITY = 0x80, 24 | OBJECT_TYPE_NO_SUN_SHADOWS = 0x100, 25 | OBJECT_TYPE_RENDER_WITH_DYNAMIC = 0x200, 26 | OBJECT_TYPE_RENDER_TO_CUBEMAPS = 0x400, 27 | OBJECT_TYPE_MODEL_HAS_LODS = 0x800, 28 | OBJECT_TYPE_OVERLAY = 0x2000, 29 | OBJECT_TYPE_PRECOMPUTED_VISMEMBERS = 0x4000, 30 | OBJECT_TYPE_STATIC_CUBE_MAP = 0x8000 31 | }; 32 | // Parent: None 33 | // Fields count: 14 34 | // 35 | // Metadata: 36 | // MGetKV3ClassDefaults 37 | namespace SceneObject_t { 38 | constexpr std::ptrdiff_t m_nObjectID = 0x0; // uint32 39 | constexpr std::ptrdiff_t m_vTransform = 0x4; // Vector4D[3] 40 | constexpr std::ptrdiff_t m_flFadeStartDistance = 0x34; // float32 41 | constexpr std::ptrdiff_t m_flFadeEndDistance = 0x38; // float32 42 | constexpr std::ptrdiff_t m_vTintColor = 0x3C; // Vector4D 43 | constexpr std::ptrdiff_t m_skin = 0x50; // CUtlString 44 | constexpr std::ptrdiff_t m_nObjectTypeFlags = 0x58; // ObjectTypeFlags_t 45 | constexpr std::ptrdiff_t m_vLightingOrigin = 0x5C; // Vector 46 | constexpr std::ptrdiff_t m_nOverlayRenderOrder = 0x68; // int16 47 | constexpr std::ptrdiff_t m_nLODOverride = 0x6A; // int16 48 | constexpr std::ptrdiff_t m_nCubeMapPrecomputedHandshake = 0x6C; // int32 49 | constexpr std::ptrdiff_t m_nLightProbeVolumePrecomputedHandshake = 0x70; // int32 50 | constexpr std::ptrdiff_t m_renderableModel = 0x78; // CStrongHandle 51 | constexpr std::ptrdiff_t m_renderable = 0x80; // CStrongHandle 52 | } 53 | // Parent: None 54 | // Fields count: 3 55 | // 56 | // Metadata: 57 | // MGetKV3ClassDefaults 58 | namespace AggregateLODSetup_t { 59 | constexpr std::ptrdiff_t m_vLODOrigin = 0x0; // Vector 60 | constexpr std::ptrdiff_t m_fMaxObjectScale = 0xC; // float32 61 | constexpr std::ptrdiff_t m_fSwitchDistances = 0x10; // CUtlVector 62 | } 63 | // Parent: BaseSceneObjectOverride_t 64 | // Fields count: 4 65 | // 66 | // Metadata: 67 | // MGetKV3ClassDefaults 68 | namespace ExtraVertexStreamOverride_t { 69 | constexpr std::ptrdiff_t m_nSubSceneObject = 0x4; // uint32 70 | constexpr std::ptrdiff_t m_nDrawCallIndex = 0x8; // uint32 71 | constexpr std::ptrdiff_t m_nAdditionalMeshDrawPrimitiveFlags = 0xC; // MeshDrawPrimitiveFlags_t 72 | constexpr std::ptrdiff_t m_extraBufferBinding = 0x10; // CRenderBufferBinding 73 | } 74 | // Parent: None 75 | // Fields count: 3 76 | // 77 | // Metadata: 78 | // MGetKV3ClassDefaults 79 | namespace ClutterTile_t { 80 | constexpr std::ptrdiff_t m_nFirstInstance = 0x0; // uint32 81 | constexpr std::ptrdiff_t m_nLastInstance = 0x4; // uint32 82 | constexpr std::ptrdiff_t m_BoundsWs = 0x8; // AABB_t 83 | } 84 | // Parent: None 85 | // Fields count: 8 86 | // 87 | // Metadata: 88 | // MGetKV3ClassDefaults 89 | namespace AggregateSceneObject_t { 90 | constexpr std::ptrdiff_t m_allFlags = 0x0; // ObjectTypeFlags_t 91 | constexpr std::ptrdiff_t m_anyFlags = 0x4; // ObjectTypeFlags_t 92 | constexpr std::ptrdiff_t m_nLayer = 0x8; // int16 93 | constexpr std::ptrdiff_t m_aggregateMeshes = 0x10; // CUtlVector 94 | constexpr std::ptrdiff_t m_lodSetups = 0x28; // CUtlVector 95 | constexpr std::ptrdiff_t m_visClusterMembership = 0x40; // CUtlVector 96 | constexpr std::ptrdiff_t m_fragmentTransforms = 0x58; // CUtlVector 97 | constexpr std::ptrdiff_t m_renderableModel = 0x70; // CStrongHandle 98 | } 99 | // Parent: None 100 | // Fields count: 7 101 | // 102 | // Metadata: 103 | // MGetKV3ClassDefaults 104 | namespace NodeData_t { 105 | constexpr std::ptrdiff_t m_nParent = 0x0; // int32 106 | constexpr std::ptrdiff_t m_vOrigin = 0x4; // Vector 107 | constexpr std::ptrdiff_t m_vMinBounds = 0x10; // Vector 108 | constexpr std::ptrdiff_t m_vMaxBounds = 0x1C; // Vector 109 | constexpr std::ptrdiff_t m_flMinimumDistance = 0x28; // float32 110 | constexpr std::ptrdiff_t m_ChildNodeIndices = 0x30; // CUtlVector 111 | constexpr std::ptrdiff_t m_worldNodePrefix = 0x48; // CUtlString 112 | } 113 | // Parent: None 114 | // Fields count: 0 115 | namespace VMapResourceData_t { 116 | } 117 | // Parent: None 118 | // Fields count: 8 119 | // 120 | // Metadata: 121 | // MGetKV3ClassDefaults 122 | namespace ClutterSceneObject_t { 123 | constexpr std::ptrdiff_t m_Bounds = 0x0; // AABB_t 124 | constexpr std::ptrdiff_t m_flags = 0x18; // ObjectTypeFlags_t 125 | constexpr std::ptrdiff_t m_nLayer = 0x1C; // int16 126 | constexpr std::ptrdiff_t m_instancePositions = 0x20; // CUtlVector 127 | constexpr std::ptrdiff_t m_instanceScales = 0x50; // CUtlVector 128 | constexpr std::ptrdiff_t m_instanceTintSrgb = 0x68; // CUtlVector 129 | constexpr std::ptrdiff_t m_tiles = 0x80; // CUtlVector 130 | constexpr std::ptrdiff_t m_renderableModel = 0x98; // CStrongHandle 131 | } 132 | // Parent: None 133 | // Fields count: 5 134 | // 135 | // Metadata: 136 | // MGetKV3ClassDefaults 137 | namespace WorldBuilderParams_t { 138 | constexpr std::ptrdiff_t m_flMinDrawVolumeSize = 0x0; // float32 139 | constexpr std::ptrdiff_t m_bBuildBakedLighting = 0x4; // bool 140 | constexpr std::ptrdiff_t m_bakedLightingInfo = 0x8; // BakedLightingInfo_t 141 | constexpr std::ptrdiff_t m_nCompileTimestamp = 0x38; // uint64 142 | constexpr std::ptrdiff_t m_nCompileFingerprint = 0x40; // uint64 143 | } 144 | // Parent: None 145 | // Fields count: 3 146 | // 147 | // Metadata: 148 | // MGetKV3ClassDefaults 149 | namespace PermEntityLumpData_t { 150 | constexpr std::ptrdiff_t m_name = 0x8; // CUtlString 151 | constexpr std::ptrdiff_t m_childLumps = 0x10; // CUtlVector> 152 | constexpr std::ptrdiff_t m_entityKeyValues = 0x28; // CUtlLeanVector 153 | } 154 | // Parent: None 155 | // Fields count: 13 156 | // 157 | // Metadata: 158 | // MGetKV3ClassDefaults 159 | namespace WorldNode_t { 160 | constexpr std::ptrdiff_t m_sceneObjects = 0x0; // CUtlVector 161 | constexpr std::ptrdiff_t m_infoOverlays = 0x18; // CUtlVector 162 | constexpr std::ptrdiff_t m_visClusterMembership = 0x30; // CUtlVector 163 | constexpr std::ptrdiff_t m_aggregateSceneObjects = 0x48; // CUtlVector 164 | constexpr std::ptrdiff_t m_clutterSceneObjects = 0x60; // CUtlVector 165 | constexpr std::ptrdiff_t m_extraVertexStreamOverrides = 0x78; // CUtlVector 166 | constexpr std::ptrdiff_t m_materialOverrides = 0x90; // CUtlVector 167 | constexpr std::ptrdiff_t m_extraVertexStreams = 0xA8; // CUtlVector 168 | constexpr std::ptrdiff_t m_layerNames = 0xC0; // CUtlVector 169 | constexpr std::ptrdiff_t m_sceneObjectLayerIndices = 0xD8; // CUtlVector 170 | constexpr std::ptrdiff_t m_overlayLayerIndices = 0xF0; // CUtlVector 171 | constexpr std::ptrdiff_t m_grassFileName = 0x108; // CUtlString 172 | constexpr std::ptrdiff_t m_nodeLightingInfo = 0x110; // BakedLightingInfo_t 173 | } 174 | // Parent: None 175 | // Fields count: 1 176 | // 177 | // Metadata: 178 | // MGetKV3ClassDefaults 179 | namespace BaseSceneObjectOverride_t { 180 | constexpr std::ptrdiff_t m_nSceneObjectIndex = 0x0; // uint32 181 | } 182 | // Parent: None 183 | // Fields count: 7 184 | // 185 | // Metadata: 186 | // MGetKV3ClassDefaults 187 | namespace EntityIOConnectionData_t { 188 | constexpr std::ptrdiff_t m_outputName = 0x0; // CUtlString 189 | constexpr std::ptrdiff_t m_targetType = 0x8; // uint32 190 | constexpr std::ptrdiff_t m_targetName = 0x10; // CUtlString 191 | constexpr std::ptrdiff_t m_inputName = 0x18; // CUtlString 192 | constexpr std::ptrdiff_t m_overrideParam = 0x20; // CUtlString 193 | constexpr std::ptrdiff_t m_flDelay = 0x28; // float32 194 | constexpr std::ptrdiff_t m_nTimesToFire = 0x2C; // int32 195 | } 196 | // Parent: None 197 | // Fields count: 9 198 | // 199 | // Metadata: 200 | // MGetKV3ClassDefaults 201 | namespace BakedLightingInfo_t { 202 | constexpr std::ptrdiff_t m_nLightmapVersionNumber = 0x0; // uint32 203 | constexpr std::ptrdiff_t m_nLightmapGameVersionNumber = 0x4; // uint32 204 | constexpr std::ptrdiff_t m_vLightmapUvScale = 0x8; // Vector2D 205 | constexpr std::ptrdiff_t m_bHasLightmaps = 0x10; // bool 206 | constexpr std::ptrdiff_t m_bBakedShadowsGamma20 = 0x11; // bool 207 | constexpr std::ptrdiff_t m_bCompressionEnabled = 0x12; // bool 208 | constexpr std::ptrdiff_t m_nChartPackIterations = 0x13; // uint8 209 | constexpr std::ptrdiff_t m_nVradQuality = 0x14; // uint8 210 | constexpr std::ptrdiff_t m_lightMaps = 0x18; // CUtlVector> 211 | } 212 | // Parent: None 213 | // Fields count: 2 214 | // 215 | // Metadata: 216 | // MGetKV3ClassDefaults 217 | namespace VoxelVisBlockOffset_t { 218 | constexpr std::ptrdiff_t m_nOffset = 0x0; // uint32 219 | constexpr std::ptrdiff_t m_nElementCount = 0x4; // uint32 220 | } 221 | // Parent: None 222 | // Fields count: 0 223 | // 224 | // Metadata: 225 | // MResourceTypeForInfoType 226 | namespace InfoForResourceTypeVMapResourceData_t { 227 | } 228 | // Parent: None 229 | // Fields count: 4 230 | // 231 | // Metadata: 232 | // MGetKV3ClassDefaults 233 | namespace WorldNodeOnDiskBufferData_t { 234 | constexpr std::ptrdiff_t m_nElementCount = 0x0; // int32 235 | constexpr std::ptrdiff_t m_nElementSizeInBytes = 0x4; // int32 236 | constexpr std::ptrdiff_t m_inputLayoutFields = 0x8; // CUtlVector 237 | constexpr std::ptrdiff_t m_pData = 0x20; // CUtlVector 238 | } 239 | // Parent: None 240 | // Fields count: 9 241 | // 242 | // Metadata: 243 | // MGetKV3ClassDefaults 244 | namespace AggregateMeshInfo_t { 245 | constexpr std::ptrdiff_t m_nVisClusterMemberOffset = 0x0; // uint32 246 | constexpr std::ptrdiff_t m_nVisClusterMemberCount = 0x4; // uint8 247 | constexpr std::ptrdiff_t m_bHasTransform = 0x5; // bool 248 | constexpr std::ptrdiff_t m_nDrawCallIndex = 0x6; // int16 249 | constexpr std::ptrdiff_t m_nLODSetupIndex = 0x8; // int16 250 | constexpr std::ptrdiff_t m_nLODGroupMask = 0xA; // uint8 251 | constexpr std::ptrdiff_t m_vTintColor = 0xB; // Color 252 | constexpr std::ptrdiff_t m_objectFlags = 0x10; // ObjectTypeFlags_t 253 | constexpr std::ptrdiff_t m_nLightProbeVolumePrecomputedHandshake = 0x14; // int32 254 | } 255 | // Parent: None 256 | // Fields count: 4 257 | // 258 | // Metadata: 259 | // MGetKV3ClassDefaults 260 | namespace World_t { 261 | constexpr std::ptrdiff_t m_builderParams = 0x0; // WorldBuilderParams_t 262 | constexpr std::ptrdiff_t m_worldNodes = 0x48; // CUtlVector 263 | constexpr std::ptrdiff_t m_worldLightingInfo = 0x60; // BakedLightingInfo_t 264 | constexpr std::ptrdiff_t m_entityLumps = 0x90; // CUtlVector> 265 | } 266 | // Parent: None 267 | // Fields count: 10 268 | // 269 | // Metadata: 270 | // MGetKV3ClassDefaults 271 | namespace InfoOverlayData_t { 272 | constexpr std::ptrdiff_t m_transform = 0x0; // matrix3x4_t 273 | constexpr std::ptrdiff_t m_flWidth = 0x30; // float32 274 | constexpr std::ptrdiff_t m_flHeight = 0x34; // float32 275 | constexpr std::ptrdiff_t m_flDepth = 0x38; // float32 276 | constexpr std::ptrdiff_t m_vUVStart = 0x3C; // Vector2D 277 | constexpr std::ptrdiff_t m_vUVEnd = 0x44; // Vector2D 278 | constexpr std::ptrdiff_t m_pMaterial = 0x50; // CStrongHandle 279 | constexpr std::ptrdiff_t m_nRenderOrder = 0x58; // int32 280 | constexpr std::ptrdiff_t m_vTintColor = 0x5C; // Vector4D 281 | constexpr std::ptrdiff_t m_nSequenceOverride = 0x6C; // int32 282 | } 283 | // Parent: BaseSceneObjectOverride_t 284 | // Fields count: 3 285 | // 286 | // Metadata: 287 | // MGetKV3ClassDefaults 288 | namespace MaterialOverride_t { 289 | constexpr std::ptrdiff_t m_nSubSceneObject = 0x4; // uint32 290 | constexpr std::ptrdiff_t m_nDrawCallIndex = 0x8; // uint32 291 | constexpr std::ptrdiff_t m_pMaterial = 0x10; // CStrongHandle 292 | } 293 | // Parent: None 294 | // Fields count: 2 295 | // 296 | // Metadata: 297 | // MGetKV3ClassDefaults 298 | namespace EntityKeyValueData_t { 299 | constexpr std::ptrdiff_t m_connections = 0x8; // CUtlVector 300 | constexpr std::ptrdiff_t m_keyValuesData = 0x20; // CUtlBinaryBlock 301 | } 302 | // Parent: None 303 | // Fields count: 13 304 | // 305 | // Metadata: 306 | // MGetKV3ClassDefaults 307 | namespace CVoxelVisibility { 308 | constexpr std::ptrdiff_t m_nBaseClusterCount = 0x40; // uint32 309 | constexpr std::ptrdiff_t m_nPVSBytesPerCluster = 0x44; // uint32 310 | constexpr std::ptrdiff_t m_vMinBounds = 0x48; // Vector 311 | constexpr std::ptrdiff_t m_vMaxBounds = 0x54; // Vector 312 | constexpr std::ptrdiff_t m_flGridSize = 0x60; // float32 313 | constexpr std::ptrdiff_t m_nSkyVisibilityCluster = 0x64; // uint32 314 | constexpr std::ptrdiff_t m_nSunVisibilityCluster = 0x68; // uint32 315 | constexpr std::ptrdiff_t m_NodeBlock = 0x6C; // VoxelVisBlockOffset_t 316 | constexpr std::ptrdiff_t m_RegionBlock = 0x74; // VoxelVisBlockOffset_t 317 | constexpr std::ptrdiff_t m_EnclosedClusterListBlock = 0x7C; // VoxelVisBlockOffset_t 318 | constexpr std::ptrdiff_t m_EnclosedClustersBlock = 0x84; // VoxelVisBlockOffset_t 319 | constexpr std::ptrdiff_t m_MasksBlock = 0x8C; // VoxelVisBlockOffset_t 320 | constexpr std::ptrdiff_t m_nVisBlocks = 0x94; // VoxelVisBlockOffset_t 321 | } 322 | } 323 | } 324 | } --------------------------------------------------------------------------------