├── .gitattributes ├── ExternalHack ├── Debug │ ├── ExternalHack.exe │ ├── ExternalHack.ilk │ └── ExternalHack.pdb ├── ExternalHack.sln ├── ExternalHack │ ├── AimBot.cpp │ ├── AimBot.h │ ├── Bunnyhope.cpp │ ├── Bunnyhope.h │ ├── Config.cpp │ ├── Config.h │ ├── Debug │ │ ├── AimBot.obj │ │ ├── Config.obj │ │ ├── ExternalHack.log │ │ ├── ExternalHack.obj │ │ ├── ExternalHack.tlog │ │ │ ├── CL.command.1.tlog │ │ │ ├── CL.read.1.tlog │ │ │ ├── CL.write.1.tlog │ │ │ ├── ExternalHack.lastbuildstate │ │ │ ├── link.command.1.tlog │ │ │ ├── link.read.1.tlog │ │ │ └── link.write.1.tlog │ │ ├── GlobalVars.obj │ │ ├── Glow.obj │ │ ├── LocalPlayer.obj │ │ ├── Memory.obj │ │ ├── Player.obj │ │ ├── Renderer.obj │ │ ├── Singleton.obj │ │ ├── imgui.obj │ │ ├── imgui_demo.obj │ │ ├── imgui_draw.obj │ │ ├── imgui_impl_dx9.obj │ │ ├── imgui_impl_win32.obj │ │ ├── imgui_widgets.obj │ │ ├── menu.obj │ │ ├── vc141.idb │ │ ├── vc141.pdb │ │ ├── vec2.obj │ │ └── vec3.obj │ ├── ExternalHack.cpp │ ├── ExternalHack.vcxproj │ ├── ExternalHack.vcxproj.filters │ ├── ExternalHack.vcxproj.user │ ├── GlobalVars.cpp │ ├── GlobalVars.h │ ├── Glow.cpp │ ├── Glow.h │ ├── LocalPlayer.cpp │ ├── LocalPlayer.h │ ├── Memory.cpp │ ├── Memory.h │ ├── Player.cpp │ ├── Player.h │ ├── RCS.cpp │ ├── RCS.h │ ├── Release │ │ ├── AimBot.obj │ │ ├── Bunnyhope.obj │ │ ├── Config.obj │ │ ├── ExternalHack.Build.CppClean.log │ │ ├── ExternalHack.log │ │ ├── ExternalHack.obj │ │ ├── ExternalHack.tlog │ │ │ ├── CL.command.1.tlog │ │ │ ├── CL.read.1.tlog │ │ │ ├── CL.write.1.tlog │ │ │ ├── ExternalHack.lastbuildstate │ │ │ ├── link.command.1.tlog │ │ │ ├── link.read.1.tlog │ │ │ └── link.write.1.tlog │ │ ├── GlobalVars.obj │ │ ├── Glow.obj │ │ ├── LocalPlayer.obj │ │ ├── Memory.obj │ │ ├── Player.obj │ │ ├── RCS.obj │ │ ├── Renderer.obj │ │ ├── Singleton.obj │ │ ├── SkinChanger.obj │ │ ├── Triggerbot.obj │ │ ├── fakelag.obj │ │ ├── imgui.obj │ │ ├── imgui_demo.obj │ │ ├── imgui_draw.obj │ │ ├── imgui_impl_dx9.obj │ │ ├── imgui_impl_win32.obj │ │ ├── imgui_widgets.obj │ │ ├── menu.obj │ │ ├── vc141.pdb │ │ ├── vec2.obj │ │ └── vec3.obj │ ├── Renderer.cpp │ ├── Renderer.h │ ├── Singleton.cpp │ ├── Singleton.h │ ├── SkinChanger.cpp │ ├── SkinChanger.h │ ├── Triggerbot.cpp │ ├── Triggerbot.h │ ├── Untitled1.ttf │ ├── fakelag.cpp │ ├── fakelag.h │ ├── imgui.ini │ ├── menu.cpp │ ├── menu.h │ ├── undefeated.ttf │ ├── vec2.cpp │ ├── vec2.h │ ├── vec3.cpp │ ├── vec3.h │ ├── vgafixr.fon │ └── x64 │ │ └── Debug │ │ ├── ExternalHack.log │ │ ├── ExternalHack.tlog │ │ ├── CL.command.1.tlog │ │ ├── CL.read.1.tlog │ │ ├── CL.write.1.tlog │ │ ├── ExternalHack.lastbuildstate │ │ └── unsuccessfulbuild │ │ ├── vc141.idb │ │ └── vc141.pdb ├── IMGUI │ ├── imconfig.h │ ├── imgui.cpp │ ├── imgui.h │ ├── imgui_demo.cpp │ ├── imgui_draw.cpp │ ├── imgui_impl_dx9.cpp │ ├── imgui_impl_dx9.h │ ├── imgui_impl_win32.cpp │ ├── imgui_impl_win32.h │ ├── imgui_internal.h │ ├── imgui_widgets.cpp │ ├── imstb_rectpack.h │ ├── imstb_textedit.h │ └── imstb_truetype.h ├── Release │ ├── BRLNSB.TTF │ ├── BRLNSDB.TTF │ ├── BRLNSR.TTF │ ├── ExternalHack 28,06 UD.rar │ ├── ExternalHack.exe │ ├── Untitled1.ttf │ └── undefeated.ttf └── menu.cpp └── README.md /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /ExternalHack/Debug/ExternalHack.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Debug/ExternalHack.exe -------------------------------------------------------------------------------- /ExternalHack/Debug/ExternalHack.ilk: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Debug/ExternalHack.ilk -------------------------------------------------------------------------------- /ExternalHack/Debug/ExternalHack.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Debug/ExternalHack.pdb -------------------------------------------------------------------------------- /ExternalHack/ExternalHack.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.28307.1145 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ExternalHack", "ExternalHack\ExternalHack.vcxproj", "{7E5074ED-A4DE-42A2-90D4-1E2124E02772}" 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 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Debug|x64.ActiveCfg = Debug|x64 17 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Debug|x64.Build.0 = Debug|x64 18 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Debug|x86.ActiveCfg = Debug|Win32 19 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Debug|x86.Build.0 = Debug|Win32 20 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Release|x64.ActiveCfg = Release|x64 21 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Release|x64.Build.0 = Release|x64 22 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Release|x86.ActiveCfg = Release|Win32 23 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {A790BF44-7DB9-4D56-9556-6F53C4342B10} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/AimBot.cpp: -------------------------------------------------------------------------------- 1 | #include "AimBot.h" 2 | #include "Renderer.h" 3 | #include "LocalPlayer.h" 4 | vec3 AimBot::GetClosestTarget()//by crosshair 5 | { 6 | float max = FLT_MAX; 7 | float difference = -FLT_MAX; 8 | float differnceY = 0; 9 | clientState = memory::get().read(GlobalVars::get().engine + GlobalVars::get().ofs.dwClientState); 10 | viewAnglesAddres = (clientState + GlobalVars::get().ofs.dwClientState_ViewAngles); 11 | int index = 0; 12 | OUT_ANGLES = { ZEROTARGET, ZEROTARGET, ZEROTARGET }; 13 | for (int i = 0; i < GlobalVars::get().activeEnemyCounter; i++) 14 | { 15 | vec3 origin = GlobalVars::get().EnemyList[i]->origin; 16 | vec3 localPlayerOrigin = GlobalVars::get().localPlayer->origin; 17 | vec3 myPOS = localPlayerOrigin + GlobalVars::get().localPlayer->viewOffset; 18 | vec3 viewAngles = memory::get().read(viewAnglesAddres); 19 | vec3 bonePos = GlobalVars::get().EnemyList[i]->getBonePos(Config::get().boneList[Config::get().currBone], GlobalVars::get().EnemyList[i]->getBase()); 20 | vec2 targetAng = calculateAimAngle(myPOS, bonePos); 21 | float pitch = targetAng.x; 22 | float yaw = targetAng.y; 23 | 24 | if (viewAngles.x <= 0 && pitch <= 0) 25 | { 26 | differnceY = abs(viewAngles.x - pitch); 27 | } 28 | else if (viewAngles.x <= 0 && pitch > 0) 29 | { 30 | differnceY = abs(viewAngles.x) + pitch; 31 | } 32 | else if (viewAngles.x >= 0 && pitch < 0) 33 | { 34 | differnceY = viewAngles.x + abs(pitch); 35 | } 36 | else if (viewAngles.x >= 0 && pitch > 0) 37 | { 38 | differnceY = abs(viewAngles.x - pitch); 39 | } 40 | 41 | difference = 9999999; 42 | if (viewAngles.y >= 0 && yaw >= 0) 43 | { 44 | difference = abs(viewAngles.y - yaw); 45 | } 46 | else if (viewAngles.y >= 0 && yaw <= 0) 47 | { 48 | float buffer = abs(-180.f - yaw);// == -180 + abs(yaw) 49 | float buffer2 = 180.f - viewAngles.y; 50 | if (buffer + buffer2 <= Config::get().FOV / 3.f) 51 | { 52 | difference = abs(viewAngles.y + yaw); 53 | } 54 | else { 55 | difference = viewAngles.y - yaw;// -(-yaw) = + abs(yaw) 56 | } 57 | } 58 | else if (viewAngles.y <= 0 && yaw >= 0) 59 | { 60 | /*BUFF1, BUFF2, BUFF3*/ 61 | float buffer = 180.f - yaw;// == -180 + abs(yaw) 62 | float buffer2 = abs(-180.f - viewAngles.y); 63 | if (buffer + buffer2 <= Config::get().FOV / 3.f) 64 | { 65 | difference = abs(viewAngles.y + yaw); 66 | } 67 | else { 68 | difference = yaw - viewAngles.y; // - (-view) == +abs(view) 69 | } 70 | } 71 | else if (viewAngles.y <= 0 && yaw <= 0) 72 | { 73 | difference = abs(abs(viewAngles.y) - abs(yaw)); 74 | } 75 | float toCompare = GlobalVars::get().localPlayer->inScope ? Config::get().FOV /7.5f : Config::get().FOV / 3.f; 76 | 77 | if (difference <= toCompare && differnceY <= toCompare) 78 | { 79 | GlobalVars::get().EnemyList[i]->onFov = true; 80 | if (difference < max) 81 | { 82 | max = difference; 83 | index = i; 84 | OUT_ANGLES = { pitch, yaw, (float)i }; 85 | } 86 | /*if (diff2 <= Config::get().FOV / 3.f) { 87 | max = diff2; 88 | index = i; 89 | OUT_ANGLES = { pitch, yaw, (float)i }; 90 | }*/ 91 | } 92 | else { 93 | continue; 94 | } 95 | } 96 | return OUT_ANGLES; 97 | } 98 | vec2 AimBot::calculateAimAngle(vec3 localO, vec3 boneO) 99 | { 100 | vec3 deltaVec = { boneO.x - localO.x, boneO.y - localO.y, boneO.z - localO.z }; 101 | float lengthDeltaVec = deltaVec.length(); 102 | vec3 deltaVec2D; 103 | vec3 aimPunchAngle = memory::get().read(GlobalVars::get().localPlayer->getBase() + GlobalVars::get().ofs.m_aimPunchAngle); 104 | aimPunchAngle.x *= 2.05f; 105 | aimPunchAngle.y *= 2.05f; 106 | float yaw = atan2(deltaVec.y, deltaVec.x) * (180 / PI); 107 | yaw -= aimPunchAngle.y; 108 | float pitch = -asin(deltaVec.z / lengthDeltaVec) * (180 / PI); 109 | pitch -= aimPunchAngle.x; 110 | clamp(pitch, yaw); 111 | return vec2(pitch, yaw); 112 | } 113 | 114 | void AimBot::clamp(float & pitch, float & yaw) 115 | { 116 | if (pitch > 89.f || pitch < -89.f) 117 | { 118 | if (pitch > 89.f)pitch = 89.f; 119 | else pitch = -89.f; 120 | } 121 | if (yaw > 179.f || yaw < -179.f) 122 | { 123 | if (yaw > 179.f)yaw = -179.f;//21.06 124 | else yaw = 179.f; 125 | } 126 | } 127 | void AimBot::DoAimWrite()//not-safe aim cuz write process memory 128 | { 129 | if (GlobalVars::get().localPlayer->health > 0) 130 | { 131 | vec3 outAngles = GetClosestTarget(); 132 | int i = outAngles.z; 133 | if (GlobalVars::get().EnemyList[i] != nullptr && outAngles.x != ZEROTARGET && outAngles.y != ZEROTARGET) { 134 | GlobalVars::get().EnemyList[i]->bestAimTarget = true; 135 | } 136 | if (outAngles.x != ZEROTARGET && outAngles.y != ZEROTARGET && outAngles.z != ZEROTARGET) { 137 | int b = outAngles.z; 138 | if (GlobalVars::get().EnemyList[b]->health > 0) { 139 | vec3 viewAngles = memory::get().read(viewAnglesAddres); 140 | if (GetAsyncKeyState(Config::get().aimKey)) 141 | { 142 | bool isSpotted = GlobalVars::get().EnemyList[b]->spotted; 143 | float pitchPtr = 0; 144 | float yawPtr = 0; 145 | if (!Config::get().aimDormantCheck || (Config::get().aimDormantCheck && isSpotted)) 146 | { 147 | float buffer = 180.f - abs(viewAngles.y); 148 | bool canFov = buffer <= Config::get().FOV / 3.f; 149 | if (canFov && viewAngles.y > 0 && outAngles.y < 0) 150 | { 151 | pitchPtr = (outAngles.x - viewAngles.x) / Config::get().Smooth; 152 | yawPtr = (abs(outAngles.y + viewAngles.y) +1.f )/ Config::get().Smooth; 153 | } 154 | else if (canFov && viewAngles.y < 0 && outAngles.y >0) 155 | { 156 | pitchPtr = (outAngles.x - viewAngles.x) / Config::get().Smooth; 157 | yawPtr = ((outAngles.y + viewAngles.y)) / Config::get().Smooth - 2.f/Config::get().Smooth; 158 | } 159 | else{ 160 | pitchPtr = (outAngles.x - viewAngles.x) / Config::get().Smooth; 161 | yawPtr = (outAngles.y - viewAngles.y) / Config::get().Smooth; 162 | } 163 | float pitch = viewAngles.x + pitchPtr; 164 | float yaw = viewAngles.y + yawPtr; 165 | clamp(pitch, yaw); 166 | memory::get().write(viewAnglesAddres, pitch); 167 | memory::get().write(viewAnglesAddres + 0x4, yaw); 168 | } 169 | 170 | } 171 | } 172 | } 173 | } 174 | } 175 | 176 | void AimBot::doAimSafe() 177 | {/* 178 | view_matrix_t m = memory::get().read(GlobalVars::get().client + GlobalVars::get().ofs.m_ViewMatrix); 179 | if (GetAsyncKeyState(VK_MENU)) { 180 | vec3 outAngles = GetClosestTarget(); 181 | if (outAngles.x != ZEROTARGET && outAngles.y != ZEROTARGET) { 182 | int b = outAngles.z; 183 | POINT cp; 184 | GetCursorPos(&cp); 185 | ClientToScreen(GlobalVars::get().csgoHWND, &cp); 186 | 187 | 188 | float diffY = GlobalVars::get().RezY - (GlobalVars::get().marginRect.bottom - GlobalVars::get().marginRect.top); 189 | float distX = cp.x - GlobalVars::get().EnemyList[b]->headPos2D.x; 190 | float distY = cp.y - GlobalVars::get().EnemyList[b]->headPos2D.y; 191 | 192 | 193 | 194 | 195 | if (distX > 0) 196 | { 197 | if (distY > 0) 198 | { 199 | SetCursorPos(cp.x - distX / 2.f, GlobalVars::get().EnemyList[b]->headPos2D.y); 200 | } 201 | else { 202 | SetCursorPos(cp.x - distX / 2.f, GlobalVars::get().EnemyList[b]->headPos2D.y); 203 | } 204 | } 205 | else { 206 | if (distY > 0) 207 | { 208 | SetCursorPos(cp.x + abs(distX / 2.f), GlobalVars::get().EnemyList[b]->headPos2D.y); 209 | } 210 | else { 211 | SetCursorPos(cp.x + abs(distX / 2.f), GlobalVars::get().EnemyList[b]->headPos2D.y); 212 | } 213 | } 214 | } 215 | }*/ 216 | } 217 | 218 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/AimBot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "Singleton.h" 4 | #include "GlobalVars.h" 5 | #include "vec2.h" 6 | #define PI 3.14 7 | #define ZEROTARGET -200 8 | class AimBot : public Singleton 9 | { 10 | public: 11 | vec3 GetClosestTarget(); 12 | void DoAimWrite(); 13 | void doAimSafe(); 14 | vec2 calculateAimAngle(vec3 localO, vec3 boneO); 15 | void clamp(float& pitch, float& yaw); 16 | private: 17 | vec3 OUT_ANGLES = { ZEROTARGET,ZEROTARGET,ZEROTARGET }; 18 | uintptr_t clientState; 19 | uintptr_t viewAnglesAddres; 20 | }; 21 | 22 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Bunnyhope.cpp: -------------------------------------------------------------------------------- 1 | #include "Bunnyhope.h" 2 | #include 3 | #include 4 | enum FLAGS { 5 | FL_ON_GROUND = 257, 6 | FL_JUMP = 256, 7 | FL_DUCK = 263, 8 | }; 9 | void Bunnyhope::WriteBHOP() 10 | { 11 | if (GetAsyncKeyState(VK_SPACE)) 12 | { 13 | if (memory::get().read(GlobalVars::get().localPlayer->getBase() + GlobalVars::get().ofs.dwFlags) == FL_ON_GROUND) 14 | { 15 | memory::get().write(GlobalVars::get().client + GlobalVars::get().ofs.dwForceJump, 5);//press 16 | static DWORD now = GetTickCount64(); 17 | std::this_thread::sleep_for(std::chrono::milliseconds(12)); 18 | memory::get().write(GlobalVars::get().client + GlobalVars::get().ofs.dwForceJump, 4);//press 19 | 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Bunnyhope.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include "GlobalVars.h" 4 | class Bunnyhope : public Singleton 5 | { 6 | public: 7 | void WriteBHOP(); 8 | private: 9 | 10 | }; 11 | 12 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Config.cpp: -------------------------------------------------------------------------------- 1 | #include "Config.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include "LocalPlayer.h" 8 | # if defined(_MSC_VER) 9 | # ifndef _CRT_SECURE_NO_DEPRECATE 10 | # define _CRT_SECURE_NO_DEPRECATE (1) 11 | # endif 12 | # pragma warning(disable : 4996) 13 | # endif 14 | void CFG::save() 15 | { 16 | 17 | std::fstream file; 18 | file.open("cfg.cfg", std::ios::out | std::ios::in | std::ios::trunc); 19 | for (int i = 0; i < boolCurr; i++) 20 | { 21 | file << "[bool]"; 22 | file << BoolsList[i].name; file << "="; 23 | *BoolsList[i].value == true ? file << "1\n" : file << "0\n"; 24 | BoolsList[i].index = i; 25 | } 26 | for (int i = 0; i < IntCurr; i++) 27 | { 28 | file << "[int]"; 29 | file << IntList[i].name; file << "="; 30 | file < \n" ; 59 | file << "credits : Yougame.biz - https://yougame.biz/members/66500/" << "\n"; 60 | file << "Youtube << https://www.youtube.com/channel/UCux9Try5PKp4u5FISnT4u6w<< \n"; 61 | file.close(); 62 | } 63 | bool contains(std::string string, const char* symbols) 64 | { 65 | int rightS = 0; 66 | for (int i = 0; i < strlen(symbols); i++) 67 | { 68 | if (string[i] == symbols[i]) 69 | { 70 | rightS++; 71 | } 72 | } 73 | if (rightS == strlen(symbols)) 74 | return true; 75 | else return false; 76 | } 77 | int containsAt(std::string string, char symbol) 78 | { 79 | for (int i = 0; i < string.length(); i++) 80 | { 81 | if (string.c_str()[i] == symbol) 82 | { 83 | return i; 84 | } 85 | } 86 | return -1000; 87 | } 88 | void CFG::load() 89 | { 90 | std::ifstream file; 91 | file.open("cfg.cfg", std::ios::out); 92 | std::string buffer; 93 | bool shouldRead = true; 94 | boolCurr = 0; 95 | IntCurr = 0; 96 | FCurr = 0; 97 | while (shouldRead) 98 | { 99 | std::getline(file, buffer); 100 | int whereRead = containsAt(buffer, '='); 101 | if (contains(buffer, "[bool]")) { 102 | for (int i = whereRead; i < buffer.length(); i++) 103 | { 104 | if (buffer[i] == '1' || buffer[i] == '0') { 105 | *BoolsList[boolCurr].value = buffer[i] == '1' ? true : false; 106 | } 107 | if (i + 1 == buffer.length()) boolCurr++; 108 | } 109 | } 110 | if (contains(buffer, "[int]")) 111 | { 112 | std::string f = ""; 113 | for (int i = whereRead + 1; i < buffer.length(); i++) 114 | { 115 | f += buffer[i]; 116 | } 117 | *IntList[IntCurr].value = std::stoi(f); 118 | IntCurr++; 119 | } 120 | if (contains(buffer, "[float]")) 121 | { 122 | 123 | std::string f = ""; 124 | int currValue = 0; 125 | for (int i = whereRead + 2; i < buffer.length() - 1; i++) 126 | { 127 | if (buffer[i] != ',') 128 | { 129 | f += buffer[i]; 130 | floatList[FCurr].value[currValue] = std::stof(f); 131 | } 132 | else { 133 | currValue++; 134 | f.clear(); 135 | } 136 | } 137 | FCurr++; 138 | } 139 | for (int i = 0; i < Config::get().skinItems; i++) 140 | { 141 | if (contains(buffer, "[weapon name]=")) 142 | { 143 | int whereRead = containsAt(buffer, '='); 144 | std::string f = ""; 145 | for (int j = whereRead + 1; j < buffer.length(); j++) 146 | { 147 | f += buffer[j]; 148 | } 149 | int ID = LocalPlayer::get().getIdByName(f); 150 | // if (ID <= Config::get().skinItems) { 151 | for (int j = 0; j < 5; j++) 152 | { 153 | std::getline(file, buffer); 154 | if (contains(buffer, "[weapon pattern]=")) 155 | { 156 | int whereRead = containsAt(buffer, '='); 157 | std::string patter = ""; 158 | for (int z = whereRead + 1; z < buffer.length(); z++) 159 | { 160 | patter += buffer[z]; 161 | } 162 | Config::get().cfgWeapons[ID].skinId = std::stoi(patter); 163 | } 164 | else if (contains(buffer, "[weapon seed]=")) { 165 | int whereRead = containsAt(buffer, '='); 166 | std::string seed = ""; 167 | for (int z = whereRead + 1; z < buffer.length(); z++) 168 | { 169 | seed += buffer[z]; 170 | } 171 | Config::get().cfgWeapons[ID].seed = std::stoi(seed); 172 | } 173 | else if (contains(buffer, "[weapon wear]=")) 174 | { 175 | int whereRead = containsAt(buffer, '='); 176 | std::string wear = ""; 177 | for (int z = whereRead + 1; z < buffer.length(); z++) 178 | { 179 | wear += buffer[z]; 180 | } 181 | Config::get().cfgWeapons[ID].wear = std::stoi(wear); 182 | } 183 | else if (contains(buffer, "[weapon customName]=")) { 184 | int whereRead = containsAt(buffer, '='); 185 | std::string customName = ""; 186 | for (int z = whereRead + 1; z < buffer.length(); z++) 187 | { 188 | customName += buffer[z]; 189 | } 190 | Config::get().cfgWeapons[ID].customName = customName; 191 | } 192 | else if (contains(buffer, "[weapon currCombo]=")) 193 | { 194 | int whereRead = containsAt(buffer, '='); 195 | std::string combo = ""; 196 | for (int z = whereRead + 1; z < buffer.length(); z++) 197 | { 198 | combo += buffer[z]; 199 | } 200 | Config::get().cfgWeapons[ID].currComboSelect = std::stoi(combo); 201 | } 202 | } 203 | // } 204 | } 205 | } 206 | 207 | if (buffer.empty()) 208 | { 209 | shouldRead = false; 210 | } 211 | } 212 | std::cout << "Config loaded \n"; 213 | file.close(); 214 | } 215 | 216 | 217 | 218 | 219 | 220 | void Config::SafeCfg() 221 | { 222 | CFG::get().boolCurr = 0; 223 | CFG::get().IntCurr = 0; 224 | CFG::get().FCurr = 0; 225 | /*BOOLS*/ 226 | CFG::get().addVariable(&BoxEsp, "BoxEsp");//1 227 | CFG::get().addVariable(&LineEsp, "LineEsp"); 228 | CFG::get().addVariable(&HpEsp, "HpEsp"); 229 | CFG::get().addVariable(&Glow, "Glow"); 230 | CFG::get().addVariable(&TeamEsp, "TeamEsp"); 231 | CFG::get().addVariable(&isVisible, "isVisible");//5 232 | CFG::get().addVariable(&onVisible, "onVisible"); 233 | CFG::get().addVariable(&chams, "chams"); 234 | CFG::get().addVariable(&RenderbestAimTarget, "RenderbestAimTarget"); 235 | CFG::get().addVariable(&showHeadPos, "showHeadPos"); 236 | CFG::get().addVariable(&drawFOV, "drawFOV");//10 237 | CFG::get().addVariable(&FOV_Outline, "FOV_Outline"); 238 | CFG::get().addVariable(&WriteAimBot, "WriteAimBot"); 239 | CFG::get().addVariable(&SafeAimBot, "SafeAimBot"); 240 | CFG::get().addVariable(&TeamAim, "TeamAim"); 241 | CFG::get().addVariable(&aimDormantCheck, "aimDormantCheck"); 242 | CFG::get().addVariable(&RCS, "RCS");//15 243 | CFG::get().addVariable(&Trigger, "Trigger"); 244 | CFG::get().addVariable(&TriggerSafe, "TriggerSafe"); 245 | CFG::get().addVariable(&BHOP, "BHOP"); 246 | CFG::get().addVariable(&safeBHOP, "safeBHOP"); 247 | CFG::get().addVariable(&safeTrigger, "safeTrigger");//20 248 | CFG::get().addVariable(&FOV_Indicate, "FOV_Indicate"); 249 | CFG::get().addVariable(&fake_lag, "fakelag"); 250 | CFG::get().addVariable(&fakelag_indicator, "fakelag_indicator"); 251 | CFG::get().addVariable(&enemyWeapon, "enemyWeapon"); 252 | CFG::get().addVariable(&skingChanger, "skingChanger"); 253 | CFG::get().addVariable(&recoilCrz, "recoilCrz"); 254 | CFG::get().addVariable(&weaponIcons, "weaponIcons"); 255 | /**/ 256 | /*INTS*/ 257 | CFG::get().addVariable(&FOV, "FOV"); 258 | CFG::get().addVariable(&Smooth, "Smooth"); 259 | CFG::get().addVariable(&hpType, "hpType"); 260 | CFG::get().addVariable(&currTypeOfBox, "currTypeOfBox"); 261 | CFG::get().addVariable(&currGlowType, "currGlowType"); 262 | CFG::get().addVariable(&currBone, "currBone"); 263 | CFG::get().addVariable(&delayBetweenShots, "delayBetweenShots"); 264 | CFG::get().addVariable(&factor, "factor"); 265 | CFG::get().addVariable(&glowThikness, "glowThikness"); 266 | 267 | 268 | /*FLOAT*/ 269 | CFG::get().addVariable(ColorBox, "color_box", 4); 270 | CFG::get().addVariable(ColorGlow, "color_glow",4); 271 | CFG::get().addVariable(onVisibleColorBox, "color_box_visible",4); 272 | CFG::get().addVariable(fovColor, "fovColor",4); 273 | CFG::get().addVariable(menuCheckboxWarningColor, "menuCheckboxWarningColor",4); 274 | CFG::get().addVariable(menuCheckboxesColor, "menuCheckboxesColor",4); 275 | CFG::get().addVariable(menuFrameColor, "menuFrameColor",4); 276 | CFG::get().addVariable(menuCheckedCBoxes, "menuCheckedCBoxes",4); 277 | CFG::get().addVariable(menuChildColor, "menuChildColor",4); 278 | CFG::get().addVariable(menuButtonColor, "menuButtonColor",4); 279 | 280 | CFG::get().save(); 281 | } 282 | 283 | void Config::LoadCfg() 284 | { 285 | CFG::get().boolCurr = 0; 286 | CFG::get().IntCurr = 0; 287 | CFG::get().FCurr = 0; 288 | /*BOOLS*/ 289 | CFG::get().addToLoad(&BoxEsp, "BoxEsp");//1 290 | CFG::get().addToLoad(&LineEsp, "LineEsp"); 291 | CFG::get().addToLoad(&HpEsp, "HpEsp"); 292 | CFG::get().addToLoad(&Glow, "Glow"); 293 | CFG::get().addToLoad(&TeamEsp, "TeamEsp"); 294 | CFG::get().addToLoad(&isVisible, "isVisible");//5 295 | CFG::get().addToLoad(&onVisible, "onVisible"); 296 | CFG::get().addToLoad(&chams, "chams"); 297 | CFG::get().addToLoad(&RenderbestAimTarget, "RenderbestAimTarget"); 298 | CFG::get().addToLoad(&showHeadPos, "showHeadPos"); 299 | CFG::get().addToLoad(&drawFOV, "drawFOV");//10 300 | CFG::get().addToLoad(&FOV_Outline, "FOV_Outline"); 301 | CFG::get().addToLoad(&WriteAimBot, "WriteAimBot"); 302 | CFG::get().addToLoad(&SafeAimBot, "SafeAimBot"); 303 | CFG::get().addToLoad(&TeamAim, "TeamAim"); 304 | CFG::get().addToLoad(&aimDormantCheck, "aimDormantCheck"); 305 | CFG::get().addToLoad(&RCS, "RCS");//15 306 | CFG::get().addToLoad(&Trigger, "Trigger"); 307 | CFG::get().addToLoad(&TriggerSafe, "TriggerSafe"); 308 | CFG::get().addToLoad(&BHOP, "BHOP"); 309 | CFG::get().addToLoad(&safeBHOP, "safeBHOP"); 310 | CFG::get().addToLoad(&safeTrigger, "safeTrigger");//20 311 | CFG::get().addToLoad(&FOV_Indicate, "FOV_Indicate"); 312 | CFG::get().addToLoad(&fake_lag, "fakelag"); 313 | CFG::get().addToLoad(&fakelag_indicator, "fakelag_indicator"); 314 | CFG::get().addToLoad(&enemyWeapon, "enemyWeapon"); 315 | CFG::get().addToLoad(&skingChanger, "skingChanger"); 316 | CFG::get().addToLoad(&recoilCrz, "recoilCrz"); 317 | CFG::get().addToLoad(&weaponIcons, "weaponIcons"); 318 | /*INTS*/ 319 | CFG::get().addToLoad(&FOV, "FOV"); 320 | CFG::get().addToLoad(&Smooth, "Smooth"); 321 | CFG::get().addToLoad(&hpType, "hpType"); 322 | CFG::get().addToLoad(&currTypeOfBox, "currTypeOfBox"); 323 | CFG::get().addToLoad(&currGlowType, "currGlowType"); 324 | CFG::get().addToLoad(&currBone, "currBone"); 325 | CFG::get().addToLoad(&delayBetweenShots, "delayBetweenShots"); 326 | CFG::get().addToLoad(&factor, "factor"); 327 | CFG::get().addToLoad(&glowThikness, "glowThikness"); 328 | 329 | /*FLOAT*/ 330 | CFG::get().addToLoad(ColorBox, "color_box"); 331 | CFG::get().addToLoad(ColorGlow, "color_glow"); 332 | CFG::get().addToLoad(onVisibleColorBox, "color_box_visible"); 333 | CFG::get().addToLoad(fovColor, "fovColor"); 334 | CFG::get().addToLoad(menuCheckboxWarningColor, "menuCheckboxWarningColor"); 335 | CFG::get().addToLoad(menuCheckboxesColor, "menuCheckboxesColor"); 336 | CFG::get().addToLoad(menuFrameColor, "menuFrameColor"); 337 | CFG::get().addToLoad(menuCheckedCBoxes, "menuCheckedCBoxes"); 338 | CFG::get().addToLoad(menuChildColor, "menuChildColor"); 339 | CFG::get().addToLoad(menuButtonColor, "menuButtonColor"); 340 | 341 | 342 | CFG::get().load(); 343 | } 344 | 345 | void Config::ResetCFG() 346 | { 347 | BoxEsp = false; 348 | LineEsp = false; 349 | HpEsp = false; 350 | currTypeOfBox = 1; 351 | currGlowType = 1; 352 | FOV = 1; 353 | Smooth = 1; 354 | drawFOV = false; 355 | FOV_Outline = false; 356 | TriggerSafe = false; 357 | Trigger = false; 358 | aimDormantCheck = false; 359 | onVisible = false; 360 | isVisible = false; 361 | hpType = 1; 362 | currBone = 1; 363 | BHOP = false; 364 | RCS = false; 365 | Glow = false; 366 | TeamEsp = false; 367 | TeamAim = false; 368 | RenderbestAimTarget = false; 369 | FOV_Indicate = false; 370 | chams = false; 371 | ColorBox[0] = 0.f; 372 | ColorBox[1] = 1.f; 373 | ColorBox[2] = 0.f; 374 | ColorBox[3] = 1.f; 375 | onVisibleColorBox[0] = 1.f; 376 | onVisibleColorBox[1] = 0.f; 377 | onVisibleColorBox[2] = 0.f; 378 | onVisibleColorBox[3] = 1.f; 379 | ColorGlow[0] = 1.f; 380 | ColorGlow[1] = 0.f; 381 | ColorGlow[2] = 1.f; 382 | ColorGlow[3] = 1.f; 383 | 384 | SafeCfg(); 385 | 386 | } 387 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Config.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include "vec3.h" 4 | #include 5 | #include 6 | enum AimPrefer { 7 | closest, 8 | center, 9 | hp, 10 | closest_center, 11 | closest_hp, 12 | center_hp 13 | }; 14 | 15 | 16 | class CFG : public Singleton { 17 | public: 18 | template 19 | void addVariable(T* var, const char* name, int num = 1);//22.06 updated 20 | void save(); 21 | void load(); 22 | template 23 | void addToLoad(T* toChange, const char* name); 24 | template 25 | struct variable { 26 | const char* name; 27 | T* value; 28 | int index; 29 | int arraySize; 30 | }; 31 | public: 32 | int boolCurr = 0; 33 | int IntCurr = 0; 34 | int FCurr = 0; 35 | private: 36 | const char* filePath = "C:\\Users\\CFG\\config.cfg ";//incorrect 21.06 FIX THIS SHIT PLZ 37 | const char* fileName = "config.cfg"; 38 | variable floatList[500]; 39 | variable BoolsList[500]; 40 | variable IntList[500]; 41 | }; 42 | 43 | struct SkinCFG { 44 | std::string customName = "skin"; 45 | const char* weaponName = ""; 46 | int skinId =38; 47 | float wear = 0.01f; 48 | int seed = 0; 49 | int statTrack = 0; 50 | int currComboSelect = 0; 51 | }; 52 | class Config : public Singleton 53 | { 54 | public: 55 | /*VISUALS BOOL*/ 56 | bool BoxEsp = false; 57 | bool LineEsp = false; 58 | bool HpEsp = false; 59 | bool NameEsp = false; 60 | bool Glow = false; 61 | bool TeamEsp = false; 62 | bool isVisible = false; 63 | bool onVisible = false; 64 | bool chams = false; 65 | bool RenderbestAimTarget = false; 66 | bool showHeadPos = false; 67 | bool drawFOV = false; 68 | bool FOV_Outline = false; 69 | bool FOV_Indicate = false; 70 | bool fakelag_indicator = false; 71 | bool enemyWeapon = false; 72 | bool recoilCrz = false; 73 | bool weaponIcons = true; 74 | /*VISUALS BOOL : END*/ 75 | /*----- -----*/ 76 | float ColorGlow[4] = { 1.f,0.f,1.f,1.f }; 77 | float ColorBox[4] = {.0f,1.f,0.f,1.f}; 78 | float onVisibleColorBox[4] = {1.f,0.f,0.f,1.f}; 79 | float fovColor[4] = { 1.f,0.f,1.f,1.f }; 80 | const char* boxType[3] = { "corner" , "default", "second-corner" }; 81 | const char* hptype[7] = { "top" , "bottom", "left", "right", "top txt", "bottom txt", "up scale + txt" }; 82 | const char* glowType[3] = { "default" , "pulse", "outline" }; 83 | int currTypeOfBox = 1; 84 | int currGlowType = 1; 85 | int hpType = 0; 86 | int glowThikness = 5; 87 | /*----- -----*/ 88 | 89 | /*----- -----*/ 90 | bool WriteAimBot = false; 91 | bool SafeAimBot = false; 92 | bool TeamAim = false; 93 | bool aimDormantCheck = false; 94 | bool RCS = false; 95 | bool Trigger = false; 96 | bool TriggerSafe = false; 97 | bool fake_lag = false; 98 | /*----- -----*/ 99 | 100 | /*----- -----*/ 101 | DWORD aimKey = VK_MENU; 102 | int Smooth = 1; 103 | int FOV = 1; 104 | int delayBetweenShots = 1; 105 | int factor = 1; 106 | const char* aim_preference[4] = { "head" , "body", "pelvis", "Neck"}; 107 | int boneList[4] = {8,0,9,70}; 108 | int currBone = 0; 109 | /*----- -----*/ 110 | bool BHOP = false; 111 | bool safeBHOP = false; 112 | bool safeTrigger = false; 113 | 114 | 115 | bool skingChanger = false; 116 | const int skinItems = 22;//change 117 | int currComboWeaponSkin = 0; 118 | const char* skinchanger_skins[22] = {"glock-18","usp-s","p250","five-seven","dual-berets","deagle","r8", "ump-45", "mp-9","mp-7", "mac-10","famas","Galil-Ar","ak-47","m4a1", "m4a1-s","ssg08","awp","scar-20","G3SG1","aug", "sg553" }; 119 | const char* skins[14] = {"4erepa","crimson web", "fade", "blaze", "fire serpent", "Dragon Lore","Aquamarine", "Hot Rod","Medusa","MetalicDDPAT", "Neo Noir","BOOM","Emerald","Asiimov" }; 120 | SkinCFG cfgWeapons[22]; 121 | 122 | float menuCheckboxWarningColor[4] = { .8f,.3f,0.2f,1.f }; 123 | float menuCheckboxesColor[4] = { .1f,.1f,.1f,1.f }; 124 | float menuFrameColor[4] = { 0.f,0.f,0.f,1.f }; 125 | float menuCheckedCBoxes[4] = { .11f,.6f,0.05f,1.f }; 126 | float menuChildColor[4] = { .1f,.1f,.1f,1.f }; 127 | float menuButtonColor[4] = { .1f,.1f,.1f,1.f }; 128 | 129 | void SafeCfg(); 130 | void LoadCfg(); 131 | void ResetCFG(); 132 | private: 133 | }; 134 | 135 | template 136 | inline void CFG::addVariable(T * var, const char * name, int num) 137 | { 138 | if (typeid(T) == typeid(bool)) { 139 | BoolsList[boolCurr].name = name; 140 | BoolsList[boolCurr].value = reinterpret_cast(var); 141 | boolCurr++; 142 | } 143 | if (typeid(T) == typeid(int)) 144 | { 145 | IntList[IntCurr].name = name; 146 | IntList[IntCurr].value = reinterpret_cast(var); 147 | IntCurr++; 148 | } 149 | if (typeid(T) == typeid(float)) 150 | { 151 | floatList[FCurr].name = name; 152 | floatList[FCurr].value = reinterpret_cast(var); 153 | floatList[FCurr].arraySize = num; 154 | FCurr++; 155 | } 156 | } 157 | 158 | template 159 | inline void CFG::addToLoad(T * toChange, const char * name) 160 | { 161 | if (typeid(T) == typeid(bool)) { 162 | BoolsList[boolCurr].value = (bool*)toChange; 163 | BoolsList[boolCurr].name = name; 164 | boolCurr++; 165 | } 166 | if (typeid(T) == typeid(int)) 167 | { 168 | IntList[IntCurr].value = (int*)toChange; 169 | IntList[IntCurr].name = name; 170 | IntCurr++; 171 | } 172 | if (typeid(T) == typeid(float)) 173 | { 174 | floatList[FCurr].value = (float*)toChange; 175 | floatList[FCurr].name = name; 176 | FCurr++; 177 | } 178 | } 179 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/AimBot.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/AimBot.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/Config.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/Config.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.log: -------------------------------------------------------------------------------- 1 |  AimBot.cpp 2 | c:\users\roman\source\repos\externalhack\externalhack\aimbot.cpp(32): warning C4244: инициализация: преобразование "double" в "float", возможна потеря данных 3 | c:\users\roman\source\repos\externalhack\externalhack\aimbot.cpp(33): warning C4244: инициализация: преобразование "double" в "float", возможна потеря данных 4 | c:\users\roman\source\repos\externalhack\externalhack\aimbot.cpp(73): warning C4244: аргумент: преобразование "float" в "uintptr_t", возможна потеря данных 5 | ExternalHack.vcxproj -> C:\Users\Roman\source\repos\ExternalHack\Debug\ExternalHack.exe 6 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/CL.command.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.tlog/CL.command.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/CL.read.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.tlog/CL.read.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/CL.write.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.tlog/CL.write.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/ExternalHack.lastbuildstate: -------------------------------------------------------------------------------- 1 | #TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.17763.0 2 | Debug|Win32|C:\Users\Roman\source\repos\ExternalHack\| 3 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/link.command.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.tlog/link.command.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/link.read.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.tlog/link.read.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/ExternalHack.tlog/link.write.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/ExternalHack.tlog/link.write.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/GlobalVars.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/GlobalVars.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/Glow.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/Glow.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/LocalPlayer.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/LocalPlayer.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/Memory.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/Memory.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/Player.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/Player.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/Renderer.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/Renderer.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/Singleton.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/Singleton.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/imgui.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/imgui.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/imgui_demo.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/imgui_demo.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/imgui_draw.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/imgui_draw.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/imgui_impl_dx9.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/imgui_impl_dx9.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/imgui_impl_win32.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/imgui_impl_win32.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/imgui_widgets.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/imgui_widgets.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/menu.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/menu.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/vc141.idb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/vc141.idb -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/vc141.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/vc141.pdb -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/vec2.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/vec2.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Debug/vec3.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Debug/vec3.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/ExternalHack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "Memory.h" 3 | #include "GlobalVars.h" 4 | #include "Renderer.h" 5 | #include 6 | #include 7 | #include 8 | #include "AimBot.h" 9 | #include "RCS.h" 10 | #include "Bunnyhope.h" 11 | #include "Triggerbot.h" 12 | #include "fakelag.h" 13 | #include "SkinChanger.h" 14 | #include 15 | #pragma comment (lib, "Dwmapi.lib") 16 | 17 | static bool shouldDestroy = false;//if true -> destroy window 18 | LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); 19 | int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow); 20 | int main() 21 | { 22 | std::cout << "ExternalHack by Roman (23.06.2020); \n"; 23 | std::cout << "Statuc << UNDETECT; \n"; 24 | std::cout << "Waiting for csgo ... \n"; 25 | Sleep(2000); 26 | GlobalVars::get().pId = memory::get().getProcessId("csgo.exe"); 27 | if(GlobalVars::get().pId != 0) 28 | std::cout << "Process Id of CSGO is << " << GlobalVars::get().pId << " << \n"; 29 | else { 30 | while (GlobalVars::get().pId == 0) 31 | { 32 | GlobalVars::get().pId = memory::get().getProcessId("csgo.exe"); 33 | GlobalVars::get().pId == 0 ? std::cout << "Waiting for csgo ... \n" : std::cout << "CSGO FOUND, procID = " << GlobalVars::get().pId << " \n"; 34 | Sleep(2500); 35 | } 36 | } 37 | GlobalVars::get().client = memory::get().GetBase("client.dll"); 38 | std::cout << "Search for " << " client.dll " << " in csgo.exe" << " addres = " << GlobalVars::get().client << "\n"; 39 | GlobalVars::get().engine = memory::get().GetBase("engine.dll"); 40 | std::cout << "Search for " << " engine.dll " << " in csgo.exe" << " addres = " << GlobalVars::get().engine << "\n"; 41 | GlobalVars::get().vstdlib = memory::get().GetBase("vstdlib.dll"); 42 | GlobalVars::get().csgo = OpenProcess(PROCESS_ALL_ACCESS, 0, GlobalVars::get().pId); 43 | try { 44 | std::ifstream file; 45 | file.open("cfg.cfg", std::ios::out); 46 | if (file.is_open()) 47 | { 48 | Config::get().LoadCfg(); 49 | } 50 | else { 51 | throw "cfg doesnt exist "; 52 | } 53 | } 54 | catch (const char* error) 55 | { 56 | std::cout << error << "\n"; 57 | } 58 | GlobalVars::get().printOffsets(); 59 | WinMain(0, 0, 0, 1); 60 | fakelag::get().shutdown(); 61 | CloseHandle(GlobalVars::get().csgo); 62 | std::cout << "cheat going to sleep \n\n zzzzzzz"; 63 | } 64 | const MARGINS margin = { 0, 0, GlobalVars::get().overlayRect.right - GlobalVars::get().overlayRect.left , GlobalVars::get().overlayRect.bottom - GlobalVars::get().overlayRect.top }; 65 | LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) 66 | { 67 | switch (uMsg) { 68 | case WM_DESTROY: 69 | GlobalVars::get().pDevice->Release(); 70 | exit(0); 71 | break; 72 | default: 73 | return DefWindowProc(hwnd, uMsg, wParam, lParam); 74 | } 75 | } 76 | bool initD3D(HWND hwnd, IDirect3DDevice9** pDevice,int x, int y) 77 | { 78 | 79 | GlobalVars::get().g_D3D = Direct3DCreate9(D3D_SDK_VERSION); 80 | D3DPRESENT_PARAMETERS PresParam; 81 | ZeroMemory(&PresParam, sizeof(PresParam)); 82 | HRESULT hr = NULL; 83 | 84 | D3DDISPLAYMODE DisplayMode; 85 | hr = GlobalVars::get().g_D3D->GetAdapterDisplayMode( 86 | D3DADAPTER_DEFAULT, 87 | &DisplayMode); 88 | 89 | if (FAILED(hr)) 90 | return false; 91 | PresParam.Windowed = true; 92 | PresParam.SwapEffect = D3DSWAPEFFECT_DISCARD; 93 | PresParam.BackBufferFormat = D3DFMT_A8R8G8B8; 94 | PresParam.BackBufferWidth =x; 95 | PresParam.BackBufferHeight = y; 96 | PresParam.hDeviceWindow =hwnd; 97 | PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; 98 | PresParam.EnableAutoDepthStencil = true; 99 | PresParam.AutoDepthStencilFormat = D3DFMT_D16; 100 | 101 | hr = GlobalVars::get().g_D3D->CreateDevice( 102 | D3DADAPTER_DEFAULT, 103 | D3DDEVTYPE_HAL, 104 | hwnd, //overlayHWND 105 | D3DCREATE_HARDWARE_VERTEXPROCESSING, 106 | &PresParam, 107 | pDevice); 108 | if (!GlobalVars::get().defFont) 109 | { 110 | D3DXCreateFont(GlobalVars::get().pDevice, 14, 0, 0, 0, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, "Arial", &GlobalVars::get().defFont); 111 | } 112 | static bool once = false; 113 | if (SUCCEEDED(hr)) { 114 | 115 | if (!once) { 116 | std::cout << "created PDEVICE \n"; 117 | once = true; 118 | } 119 | return true; 120 | } 121 | } 122 | int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) 123 | { 124 | auto f = GetModuleHandle(NULL); 125 | WNDCLASSEX wc; 126 | wc = { 0 }; 127 | wc.cbSize = sizeof(wc); 128 | 129 | //Create our window class 130 | wc.style = CS_HREDRAW | CS_VREDRAW; 131 | wc.lpfnWndProc = WindowProc; 132 | wc.cbClsExtra = 0; 133 | wc.cbWndExtra = 0; 134 | wc.hInstance = NULL; 135 | wc.hIcon = NULL; 136 | wc.hCursor = LoadCursor(NULL, IDC_ARROW); 137 | wc.hbrBackground = HBRUSH(RGB(0, 0, 0)); 138 | wc.lpszClassName = "ExternalDLC"; 139 | wc.hIconSm = NULL; 140 | if (!RegisterClassEx(&wc)) 141 | { 142 | 143 | MessageBox(NULL, "Can`t register window class", "Error", MB_OK | MB_ICONERROR); 144 | return 0; 145 | } 146 | GlobalVars::get().csgoHWND = FindWindowA(NULL, "Counter-Strike: Global Offensive"); 147 | GetClientRect(GlobalVars::get().csgoHWND,&GlobalVars::get().overlayRect); 148 | GetWindowRect(GlobalVars::get().csgoHWND,&GlobalVars::get().marginRect); 149 | GlobalVars::get().RezX = GlobalVars::get().marginRect.right - GlobalVars::get().marginRect.left; 150 | GlobalVars::get().RezY = GlobalVars::get().overlayRect.bottom - GlobalVars::get().overlayRect.top; 151 | 152 | float diffY = GlobalVars::get().RezY - (GlobalVars::get().marginRect.bottom - GlobalVars::get().marginRect.top); 153 | 154 | GlobalVars::get().overlayHWND = CreateWindowEx(WS_EX_LAYERED | WS_EX_TRANSPARENT , 155 | "ExternalDLC", 156 | "ExternalByRoman", 157 | WS_POPUP | WS_VISIBLE, 158 | GlobalVars::get().marginRect.left, //Позиция окна по оси Х // -(minus)diff 159 | GlobalVars::get().marginRect.top - diffY, //Позиция окна по оси У 160 | GlobalVars::get().RezX, //Ширина окна 161 | GlobalVars::get().RezY, //Высота окна 162 | NULL, 163 | NULL, 164 | f, //getmodulehandle(NULL) 165 | NULL); 166 | 167 | MARGINS marg = { GlobalVars::get().marginRect.left ,GlobalVars::get().marginRect.top - diffY, GlobalVars::get().RezX ,GlobalVars::get().RezY }; 168 | SetForegroundWindow(GlobalVars::get().csgoHWND); 169 | DwmExtendFrameIntoClientArea(GlobalVars::get().overlayHWND, &marg); 170 | SetLayeredWindowAttributes(GlobalVars::get().overlayHWND, RGB(0, 0, 0), 255, LWA_ALPHA); 171 | ShowWindow(GlobalVars::get().overlayHWND, SW_SHOW); 172 | SetWindowPos(GlobalVars::get().csgoHWND, GlobalVars::get().overlayHWND, GlobalVars::get().marginRect.left, GlobalVars::get().marginRect.top - diffY, GlobalVars::get().RezX, GlobalVars::get().RezY, SWP_NOMOVE | SWP_NOSIZE); 173 | if (GlobalVars::get().overlayHWND == NULL) 174 | { 175 | MessageBox(NULL, "Can`t create window", "Error", MB_OK | MB_ICONERROR); 176 | return 0; 177 | } 178 | if (!initD3D(GlobalVars::get().overlayHWND, &GlobalVars::get().pDevice, GlobalVars::get().RezX, GlobalVars::get().RezY)) { 179 | MessageBox(NULL, "Can`t create 3D", "Error", MB_OK | MB_ICONERROR); 180 | return 0; 181 | } 182 | 183 | 184 | SetWindowPos(GlobalVars::get().overlayHWND, HWND_TOPMOST, GlobalVars::get().marginRect.left, GlobalVars::get().marginRect.top - diffY, GlobalVars::get().RezX, GlobalVars::get().RezY, SWP_NOMOVE | SWP_NOSIZE);//del swp_nomove and etc 185 | MSG msg; 186 | ZeroMemory(&msg, sizeof(msg)); 187 | while (!shouldDestroy) 188 | { 189 | if (PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))//Получаем сообщения 190 | { 191 | TranslateMessage(&msg); //Обрабатываем сообщения 192 | DispatchMessage(&msg); //Обрабатываем сообщения 193 | } 194 | else { 195 | static DWORD now = GetTickCount(); 196 | if (GetTickCount() - now > 30000) 197 | { 198 | /* now = GetTickCount(); 199 | GlobalVars::get().csgoHWND = FindWindowA(NULL, "Counter-Strike: Global Offensive");//21.06 200 | GetClientRect(GlobalVars::get().csgoHWND, &GlobalVars::get().overlayRect); 201 | GetWindowRect(GlobalVars::get().csgoHWND, &GlobalVars::get().marginRect); 202 | GlobalVars::get().RezX = GlobalVars::get().marginRect.right - GlobalVars::get().marginRect.left; 203 | GlobalVars::get().RezY = GlobalVars::get().overlayRect.bottom - GlobalVars::get().overlayRect.top; 204 | 205 | /*float diffY = GlobalVars::get().RezY - (GlobalVars::get().marginRect.bottom - GlobalVars::get().marginRect.top); 206 | SetWindowPos(GlobalVars::get().overlayHWND, HWND_TOPMOST,GlobalVars::get().marginRect.left, GlobalVars::get().marginRect.top - diffY, GlobalVars::get().RezX, GlobalVars::get().RezY,0);//del swp_nomove and etc 207 | MARGINS marg = { GlobalVars::get().marginRect.left, GlobalVars::get().marginRect.top - diffY, GlobalVars::get().RezX, GlobalVars::get().RezY }; 208 | DwmExtendFrameIntoClientArea(GlobalVars::get().overlayHWND, &marg); 209 | GlobalVars::get().pDevice->Present(0, 0, 0, 0); 210 | GlobalVars::get().pDevice->Release(); 211 | initD3D(GlobalVars::get().overlayHWND, &GlobalVars::get().pDevice, GlobalVars::get().RezX, GlobalVars::get().RezY); */ 212 | } 213 | 214 | GlobalVars::get().csgoHWND = FindWindowA(NULL, "Counter-Strike: Global Offensive");//21.06 215 | if (GlobalVars::get().csgoHWND == NULL)shouldDestroy = true; 216 | HWND hwnd = GetForegroundWindow(); 217 | 218 | if (GlobalVars::get().csgoHWND == hwnd || GlobalVars::get().overlayHWND == hwnd) {//21.06 UPDATED 219 | GlobalVars::get().updateEnemyList(); 220 | if (Config::get().WriteAimBot)AimBot::get().DoAimWrite(); 221 | if (Config::get().skingChanger)SkinChanger::get().doSkinChanger(); 222 | Renderer::get().drawFrames(); 223 | if (Config::get().fake_lag)fakelag::get().doFakeLag(); 224 | if (Config::get().Trigger || Config::get().safeTrigger)Triggerbot::get().doTriggerbot(); 225 | // if (Config::get().SafeAimBot)AimBot::get().doAimSafe(); 226 | if (Config::get().RCS)RCS::get().doRCS(); 227 | if (Config::get().BHOP)Bunnyhope::get().WriteBHOP(); 228 | 229 | GlobalVars::get().clearEnemyList(); 230 | }//21.06 231 | else { 232 | GlobalVars::get().pDevice->BeginScene(); 233 | GlobalVars::get().pDevice->Clear(0,0,D3DCLEAR_TARGET, D3DCOLOR_RGBA(0,0,0,0), 1.f, 0); 234 | menu::get().showMenu = false; 235 | GlobalVars::get().pDevice->EndScene(); 236 | GlobalVars::get().pDevice->Present(0, 0, 0, 0); 237 | } 238 | } 239 | if (GetAsyncKeyState(VK_DELETE)) 240 | { 241 | fakelag::get().shutdown(); 242 | shouldDestroy = true; 243 | } 244 | std::this_thread::sleep_for(std::chrono::milliseconds(1)); 245 | } 246 | return msg.wParam;; 247 | } 248 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/ExternalHack.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 | 15.0 23 | {7E5074ED-A4DE-42A2-90D4-1E2124E02772} 24 | Win32Proj 25 | ExternalHack 26 | 10.0.17763.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v141 33 | MultiByte 34 | false 35 | 36 | 37 | Application 38 | false 39 | v141 40 | false 41 | MultiByte 42 | 43 | 44 | Application 45 | true 46 | v141 47 | MultiByte 48 | 49 | 50 | Application 51 | false 52 | v141 53 | true 54 | MultiByte 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | true 76 | C:\Users\Roman\source\repos\ExternalHack\IMGUI;C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) 77 | C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) 78 | 79 | 80 | true 81 | C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) 82 | C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) 83 | 84 | 85 | false 86 | C:\Users\Roman\source\repos\ExternalHack\IMGUI;C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) 87 | C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) 88 | 89 | 90 | false 91 | C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Include;$(IncludePath) 92 | C:\Program Files %28x86%29\Microsoft DirectX SDK %28June 2010%29\Lib\x86;$(LibraryPath) 93 | 94 | 95 | 96 | NotUsing 97 | Level3 98 | Disabled 99 | true 100 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 101 | true 102 | stdcpp17 103 | 104 | 105 | Console 106 | true 107 | 108 | 109 | 110 | 111 | 112 | 113 | Level3 114 | Disabled 115 | true 116 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 117 | true 118 | 119 | 120 | Console 121 | true 122 | 123 | 124 | 125 | 126 | NotUsing 127 | Level3 128 | Disabled 129 | true 130 | true 131 | true 132 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 133 | true 134 | stdcpp17 135 | 136 | 137 | Console 138 | true 139 | true 140 | true 141 | 142 | 143 | 144 | 145 | 146 | 147 | Level3 148 | MaxSpeed 149 | true 150 | true 151 | true 152 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 153 | true 154 | 155 | 156 | Console 157 | true 158 | true 159 | true 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 | 215 | 216 | 217 | 218 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/ExternalHack.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | {0e55ddd1-e0d6-407f-a74f-8e0f5615985e} 18 | 19 | 20 | {c168e542-58f8-4f5a-b932-928869e52b8c} 21 | 22 | 23 | {a53439be-8509-402f-9894-06014d407835} 24 | 25 | 26 | {fb8c9efd-2726-445e-b071-7315a3da3185} 27 | 28 | 29 | {aeed1e2e-9f61-498a-91f8-b8e715da9945} 30 | 31 | 32 | {9e151b28-dcc3-4a9b-b601-2a45f6857439} 33 | 34 | 35 | {1637a4c4-a948-446e-a6be-6a4f16e3d46e} 36 | 37 | 38 | 39 | 40 | Исходные файлы 41 | 42 | 43 | Исходные файлы 44 | 45 | 46 | Исходные файлы 47 | 48 | 49 | Исходные файлы 50 | 51 | 52 | ImGui 53 | 54 | 55 | ImGui 56 | 57 | 58 | ImGui 59 | 60 | 61 | ImGui 62 | 63 | 64 | ImGui 65 | 66 | 67 | ImGui 68 | 69 | 70 | Исходные файлы\Features 71 | 72 | 73 | Исходные файлы\Main and etc 74 | 75 | 76 | Исходные файлы\Main and etc 77 | 78 | 79 | Исходные файлы\Main and etc 80 | 81 | 82 | Исходные файлы\Main and etc 83 | 84 | 85 | Исходные файлы\Main and etc 86 | 87 | 88 | Исходные файлы\MATH 89 | 90 | 91 | Исходные файлы\MATH 92 | 93 | 94 | Исходные файлы\Features 95 | 96 | 97 | Исходные файлы\Features 98 | 99 | 100 | Исходные файлы\Features 101 | 102 | 103 | Исходные файлы\Features 104 | 105 | 106 | Исходные файлы\Features 107 | 108 | 109 | Исходные файлы\Features 110 | 111 | 112 | 113 | 114 | Файлы заголовков 115 | 116 | 117 | Файлы заголовков 118 | 119 | 120 | Файлы заголовков 121 | 122 | 123 | Файлы заголовков 124 | 125 | 126 | ImGui 127 | 128 | 129 | ImGui 130 | 131 | 132 | ImGui 133 | 134 | 135 | ImGui 136 | 137 | 138 | ImGui 139 | 140 | 141 | ImGui 142 | 143 | 144 | ImGui 145 | 146 | 147 | ImGui 148 | 149 | 150 | Файлы заголовков\feauters 151 | 152 | 153 | Файлы заголовков\Main and etc 154 | 155 | 156 | Файлы заголовков\Main and etc 157 | 158 | 159 | Файлы заголовков\Main and etc 160 | 161 | 162 | Файлы заголовков\Main and etc 163 | 164 | 165 | Файлы заголовков\MATH 166 | 167 | 168 | Файлы заголовков\MATH 169 | 170 | 171 | Файлы заголовков\feauters 172 | 173 | 174 | Файлы заголовков\feauters 175 | 176 | 177 | Файлы заголовков\feauters 178 | 179 | 180 | Файлы заголовков\feauters 181 | 182 | 183 | Файлы заголовков\feauters 184 | 185 | 186 | Файлы заголовков\feauters 187 | 188 | 189 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/ExternalHack.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/GlobalVars.cpp: -------------------------------------------------------------------------------- 1 | #include "GlobalVars.h" 2 | #include "Player.h" 3 | void GlobalVars::updateEnemyList() 4 | { 5 | activeEnemyCounter = 0; 6 | activeFriendsCounter = 0; 7 | DWORD bufferL = memory::get().read(GlobalVars::get().client + GlobalVars::get().ofs.localPlayer); 8 | localPlayer = new LocalPlayer(bufferL); 9 | localPlayer->Update(); 10 | for (int i = 0; i < 64; i++) 11 | { 12 | DWORD buffer = memory::get().read(client + ofs.dwEntityList + i * 0x10); 13 | if (buffer != NULL) 14 | { 15 | Player* pEntity = new Player(memory::get().read(client + ofs.dwEntityList + i * 0x10)); 16 | pEntity->Update(); 17 | if (pEntity->health > 0 && pEntity->team != localPlayer->team && !pEntity->isDormant)//21.06 18 | { 19 | EnemyList[activeEnemyCounter] = pEntity; 20 | activeEnemyCounter++; 21 | } 22 | else if (Config::get().TeamEsp) 23 | { 24 | if (pEntity->team == localPlayer->team && pEntity->health > 0) 25 | { 26 | if (buffer != bufferL) 27 | { 28 | FriendList[activeFriendsCounter] = pEntity; 29 | activeFriendsCounter++; 30 | } 31 | } 32 | else 33 | { 34 | delete pEntity; 35 | } 36 | } 37 | else{ 38 | delete pEntity; 39 | } 40 | } 41 | } 42 | } 43 | 44 | void GlobalVars::clearEnemyList() 45 | { 46 | for (int i = 0; i < activeEnemyCounter; i++) 47 | { 48 | if(EnemyList[i] != nullptr) 49 | delete EnemyList[i]; 50 | } 51 | for (int i = 0; i < 64; i++) 52 | { 53 | if(FriendList[i]) 54 | delete FriendList[i]; 55 | } 56 | delete localPlayer; 57 | } 58 | void GlobalVars::printOffsets() 59 | { 60 | offsets* base = &ofs; 61 | std::cout << base << " = link to struct of offsets { \n\n"; 62 | for (int i = 0; i < sizeof(offsets) / sizeof(DWORD); i++) 63 | { 64 | std::cout <getBase() == entityBase) 74 | { 75 | 76 | return EnemyList[i]; 77 | } 78 | } 79 | } 80 | 81 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/GlobalVars.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "Singleton.h" 4 | #include 5 | #include 6 | #pragma comment(lib, "d3d9.lib") 7 | #pragma comment(lib, "d3dx9.lib") 8 | #include 9 | #include "Player.h" 10 | #include "Memory.h" 11 | #include "Config.h" 12 | /*GVARS.h : Player.h -> Player.h : LocalPlayer.h*/ 13 | class GlobalVars : public Singleton 14 | { 15 | public: 16 | uintptr_t client; 17 | uintptr_t engine; 18 | uintptr_t vstdlib; 19 | DWORD pId; 20 | HANDLE csgo; 21 | HWND overlayHWND; 22 | HWND csgoHWND; 23 | RECT overlayRect;//and csgo rect 24 | RECT marginRect; 25 | struct offsets { 26 | DWORD localPlayer = 0xD3ABEC; 27 | DWORD dwEntityList = 0x4D4F25C; 28 | DWORD m_ViewMatrix = 0x4D40BA4; 29 | DWORD dwGlowObjectManager = 0x5297080; 30 | DWORD dwForceJump = 0x51F8EF4; 31 | DWORD dwForceAttack = 0x31807A8; 32 | DWORD boneMatrix = 0x26A8; 33 | DWORD dwClientState = 0x58ADD4; 34 | DWORD dwClientState_ViewAngles = 0x4D88; 35 | DWORD dwbSendPackets = 0xD415A; 36 | DWORD clientstate_choked_commands = 0x4D28; 37 | DWORD m_hActiveWeapon = 0x2EF8; 38 | DWORD m_iItemDefinitionIndex = 0x2FAA; 39 | DWORD m_nFallbackStatTrak = 0x31D4; 40 | DWORD m_szCustomName = 0x303C; 41 | DWORD m_iItemIDHigh = 0x2FC0; 42 | DWORD m_nFallbackPaintKit = 0x31C8; 43 | DWORD m_nFallbackSeed = 0x31CC; 44 | DWORD m_iEntityQuality = 0x2FAC; 45 | DWORD m_flFallbackWear = 0x31D0; 46 | DWORD m_hMyWeapons = 0x2DF8; 47 | DWORD clientstate_delta_ticks = 0x174; 48 | 49 | 50 | DWORD m_iHealth = 0x100; 51 | DWORD dwFlags = 0x104; 52 | DWORD m_iTeam = 0xF4; 53 | DWORD m_vecOrigin = 0x138; 54 | DWORD vecViewOffes = 0x108; 55 | DWORD m_iGlowIndex = 0xA438; 56 | DWORD dormant = 0xED; 57 | DWORD m_aimPunchAngle = 0x302C; 58 | DWORD m_iShotsFired = 0xA390; 59 | DWORD m_viewPunchAngle = 0x3020; 60 | DWORD m_iCrosshairId = 0xB3E4; 61 | DWORD b_Spotted = 0x93D; 62 | DWORD m_bIsScoped = 0x3928; 63 | } ofs; 64 | IDirect3DDevice9* pDevice; 65 | IDirect3D9* g_D3D; 66 | ID3DXFont* defFont = nullptr; 67 | Player* EnemyList[64] = { 0 }; 68 | Player* FriendList[64]; 69 | LocalPlayer* localPlayer; 70 | int activeEnemyCounter = 0; 71 | int RezX = 0; 72 | int RezY = 0; 73 | int activeFriendsCounter = 0; 74 | void updateEnemyList(); 75 | void clearEnemyList(); 76 | void printOffsets(); 77 | Player* findEntityByBaseInList(uintptr_t entityBase); 78 | }; 79 | enum ItemDefinitionIndex 80 | { 81 | WEAPON_NONE = 0, 82 | WEAPON_DEAGLE, 83 | WEAPON_ELITE, 84 | WEAPON_FIVESEVEN, 85 | WEAPON_GLOCK, 86 | WEAPON_AK47 = 7, 87 | WEAPON_AUG, 88 | WEAPON_AWP, 89 | WEAPON_FAMAS, 90 | WEAPON_G3SG1, 91 | WEAPON_GALILAR = 13, 92 | WEAPON_M249, 93 | WEAPON_M4A1 = 16, 94 | WEAPON_MAC10, 95 | WEAPON_P90 = 19, 96 | WEAPON_MP5SD = 23, 97 | WEAPON_UMP45, 98 | WEAPON_XM1014, 99 | WEAPON_BIZON, 100 | WEAPON_MAG7, 101 | WEAPON_NEGEV, 102 | WEAPON_SAWEDOFF, 103 | WEAPON_TEC9, 104 | WEAPON_TASER, 105 | WEAPON_HKP2000, 106 | WEAPON_MP7, 107 | WEAPON_MP9, 108 | WEAPON_NOVA, 109 | WEAPON_P250, 110 | WEAPON_SCAR20 = 38, 111 | WEAPON_SG556, 112 | WEAPON_SSG08, 113 | WEAPON_KNIFEGG, 114 | WEAPON_KNIFE, 115 | WEAPON_FLASHBANG, 116 | WEAPON_HEGRENADE, 117 | WEAPON_SMOKEGRENADE, 118 | WEAPON_MOLOTOV, 119 | WEAPON_DECOY, 120 | WEAPON_INCGRENADE, 121 | WEAPON_C4, 122 | WEAPON_HEALTHSHOT = 57, 123 | WEAPON_KNIFE_T = 59, 124 | WEAPON_M4A1_SILENCER, 125 | WEAPON_USP_SILENCER, 126 | WEAPON_CZ75A = 63, 127 | WEAPON_REVOLVER, 128 | WEAPON_TAGRENADE = 68, 129 | WEAPON_FISTS, 130 | WEAPON_BREACHCHARGE, 131 | WEAPON_TABLET = 72, 132 | WEAPON_MELEE = 74, 133 | WEAPON_AXE, 134 | WEAPON_HAMMER, 135 | WEAPON_SPANNER = 78, 136 | WEAPON_KNIFE_GHOST = 80, 137 | WEAPON_FIREBOMB, 138 | WEAPON_DIVERSION, 139 | WEAPON_FRAG_GRENADE, 140 | WEAPON_BAYONET = 500, 141 | WEAPON_KNIFE_FLIP = 505, 142 | WEAPON_KNIFE_GUT, 143 | WEAPON_KNIFE_KARAMBIT, 144 | WEAPON_KNIFE_M9_BAYONET, 145 | WEAPON_KNIFE_TACTICAL, 146 | WEAPON_KNIFE_FALCHION = 512, 147 | WEAPON_KNIFE_SURVIVAL_BOWIE = 514, 148 | WEAPON_KNIFE_BUTTERFLY, 149 | WEAPON_KNIFE_PUSH, 150 | WEAPON_KNIFE_URSUS = 519, 151 | WEAPON_KNIFE_GYPSY_JACKKNIFE, 152 | WEAPON_KNIFE_STILETTO = 522, 153 | WEAPON_KNIFE_WIDOWMAKER, 154 | GLOVE_STUDDED_BLOODHOUND = 5027, 155 | GLOVE_T_SIDE = 5028, 156 | GLOVE_CT_SIDE = 5029, 157 | GLOVE_SPORTY = 5030, 158 | GLOVE_SLICK = 5031, 159 | GLOVE_LEATHER_WRAP = 5032, 160 | GLOVE_MOTORCYCLE = 5033, 161 | GLOVE_SPECIALIST = 5034, 162 | GLOVE_HYDRA = 5035 163 | }; 164 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Glow.cpp: -------------------------------------------------------------------------------- 1 | #include "Glow.h" 2 | 3 | 4 | 5 | void Glow::doGlow(Player * player) 6 | { 7 | 8 | player->getIGlow(); 9 | memory::get().write((((player->iGlow * 0x38) + 0x4) + GlowObjectManager), Config::get().ColorGlow[0]); 10 | memory::get().write((((player->iGlow * 0x38) + 0x8) + GlowObjectManager), Config::get().ColorGlow[1]); 11 | memory::get().write((((player->iGlow * 0x38) + 0xC) + GlowObjectManager), Config::get().ColorGlow[2]); 12 | memory::get().write((((player->iGlow * 0x38) + 0x10) + GlowObjectManager),Config::get().chams ? .39f : Config::get().glowThikness / 10.f + 0.1f); 13 | memory::get().write((((player->iGlow * 0x38) + 0x24) + GlowObjectManager), true); 14 | memory::get().write((((player->iGlow * 0x38) + 0x25) + GlowObjectManager), false); 15 | memory::get().write((((player->iGlow * 0x38) + 0x26) + GlowObjectManager), Config::get().chams);//full 16 | memory::get().write((((player->iGlow * 0x38) + 0x002C) + GlowObjectManager), Config::get().currGlowType);// 1 = best , 2 = small thickness 17 | } 18 | 19 | void Glow::getGlowObject() 20 | { 21 | GlowObjectManager = memory::get().read(GlobalVars::get().client + GlobalVars::get().ofs.dwGlowObjectManager); 22 | } 23 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Glow.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include 4 | #include "Player.h" 5 | #include "Memory.h" 6 | class Glow : public Singleton 7 | { 8 | public: 9 | void doGlow(Player* player); 10 | void getGlowObject(); 11 | private: 12 | uintptr_t GlowObjectManager; 13 | }; 14 | 15 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/LocalPlayer.cpp: -------------------------------------------------------------------------------- 1 | #include "LocalPlayer.h" 2 | #include "Memory.h" 3 | #include "GlobalVars.h" 4 | # if defined(_MSC_VER) 5 | # ifndef _CRT_SECURE_NO_DEPRECATE 6 | # define _CRT_SECURE_NO_DEPRECATE (1) 7 | # endif 8 | # pragma warning(disable : 4996) 9 | # endif 10 | int LocalPlayer::getHealth() 11 | { 12 | return memory::get().read(base + GlobalVars::get().ofs.m_iHealth); 13 | } 14 | 15 | int LocalPlayer::getTeam() 16 | { 17 | return memory::get().read(base + GlobalVars::get().ofs.m_iTeam); 18 | } 19 | 20 | int LocalPlayer::getFlags() 21 | { 22 | return memory::get().read(base + GlobalVars::get().ofs.dwFlags); 23 | } 24 | 25 | vec3 LocalPlayer::getOrigin() 26 | { 27 | return memory::get().read(base + GlobalVars::get().ofs.m_vecOrigin); 28 | } 29 | 30 | void LocalPlayer::Update() 31 | { 32 | health = getHealth(); 33 | team = getTeam(); 34 | flags = getFlags(); 35 | origin = getOrigin(); 36 | viewOffset = GetviewOffset(); 37 | isDormant = getDormant(); 38 | inScope = isScoping(); 39 | spotted = memory::get().read(base + GlobalVars::get().ofs.b_Spotted); 40 | } 41 | 42 | vec3 LocalPlayer::GetviewOffset() 43 | { 44 | return memory::get().read(base + GlobalVars::get().ofs.vecViewOffes); 45 | } 46 | bool LocalPlayer::getDormant() 47 | { 48 | return memory::get().read(base + GlobalVars::get().ofs.dormant); 49 | } 50 | bool LocalPlayer::isScoping() 51 | { 52 | return memory::get().read(base + GlobalVars::get().ofs.m_bIsScoped); 53 | } 54 | vec3 LocalPlayer::getBonePos(int boneId, uintptr_t base) 55 | { 56 | uintptr_t boneBase = memory::get().read(base + GlobalVars::get().ofs.boneMatrix); 57 | vec3 bonePos; 58 | 59 | bonePos.x = memory::get().read(boneBase + 0x30 * boneId + 0x0C);//0x30 = matrix3t_x4 (0x30) 60 | bonePos.y = memory::get().read(boneBase + 0x30 * boneId + 0x1C);//0x30 = matrix3t_x4 (0x30) 61 | bonePos.z = memory::get().read(boneBase + 0x30 * boneId + 0x2C);//0x30 = matrix3t_x4 (0x30) 62 | return bonePos; 63 | } 64 | 65 | int LocalPlayer::GetShotsFired() 66 | { 67 | shotsFired = memory::get().read(base + GlobalVars::get().ofs.m_iShotsFired); 68 | return shotsFired; 69 | } 70 | 71 | std::string LocalPlayer::get_weapon_name(int weaponId, bool icons) 72 | { 73 | 74 | if (!this || weaponId < 0 || weaponId > 5035) 75 | return "error"; 76 | 77 | switch (weaponId) 78 | { 79 | case WEAPON_NONE: return icons ? "" : "none"; break; 80 | case WEAPON_DEAGLE: return icons ? "A" : "deagle"; break; 81 | case WEAPON_ELITE: return icons ? "B" : "dual-berets"; break; 82 | case WEAPON_FIVESEVEN: return icons ? "C" : "five-seven"; break; 83 | case WEAPON_GLOCK: return !icons ? "glock-18" : "D"; break; 84 | case WEAPON_AK47: return !icons ? "ak-47" : "W"; break; 85 | case WEAPON_AUG: return !icons ? "aug" : "U"; break; 86 | case WEAPON_AWP: return !icons ? "awp" : "Z"; break; 87 | case WEAPON_FAMAS: return !icons ? "famas" : "R"; break; 88 | case WEAPON_G3SG1: return !icons ? "G3SG1" : "X"; break; 89 | case WEAPON_GALILAR: return !icons ? "Galil-Ar" : "Q"; break; 90 | case WEAPON_M249: return !icons ? "m249" : "g"; break; 91 | case WEAPON_M4A1: return !icons ? "m4a1" : "S"; break; 92 | case WEAPON_MAC10: return !icons ? "mac-10" : "H"; break; 93 | case WEAPON_P90: return !icons ? "petux(p90)" : "P"; break; 94 | case WEAPON_MP5SD: return !icons ? "mp5-sd" : "K"; break; 95 | case WEAPON_UMP45: return !icons ? "ump-45" : "L"; break; 96 | case WEAPON_XM1014: return !icons ? "xm1014" : "b"; break; 97 | case WEAPON_BIZON: return !icons ? "bizon" : "M"; break; 98 | case WEAPON_MAG7: return !icons ? "mag-7" : "d"; break; 99 | case WEAPON_NEGEV: return !icons ? "negev" : "f"; break; 100 | case WEAPON_SAWEDOFF: return !icons ? "sawed-off" : "c"; break; 101 | case WEAPON_TEC9: return !icons ? "tec-9" : "H"; break; 102 | case WEAPON_TASER: return !icons ? "taser" : "h"; break; 103 | case WEAPON_HKP2000: return !icons ? "p2000" : "E"; break; 104 | case WEAPON_MP7: return !icons ? "mp7" : "K"; break; 105 | case WEAPON_MP9: return !icons ? "mp9" : "O"; break; 106 | case WEAPON_NOVA: return !icons ? "nova" : "e"; break; 107 | case WEAPON_P250: return !icons ? "p250" : "F"; break; 108 | case WEAPON_SCAR20: return !icons ? "scar-20" : "Y"; break; 109 | case WEAPON_SG556: return !icons ? "sg553" : "V"; break; 110 | case WEAPON_SSG08: return !icons ? "ssg-08" : "a"; break; 111 | case WEAPON_KNIFEGG: return "knife gg"; break; 112 | case WEAPON_KNIFE: return !icons ? "knife" : "0"; break; 113 | case WEAPON_FLASHBANG: return !icons ? "flashbang" : "i"; break; 114 | case WEAPON_HEGRENADE: return !icons ? "hegrenade" : "j"; break; 115 | case WEAPON_SMOKEGRENADE: return !icons ? "smoke" : "k"; break; 116 | case WEAPON_MOLOTOV: return !icons ? "molotov" : "l"; break; 117 | case WEAPON_DECOY: return !icons ? "decoy" : "m"; break; 118 | case WEAPON_INCGRENADE: return "incgrenade"; break; 119 | case WEAPON_C4: return !icons ? "c4" : "o"; break; 120 | case WEAPON_HEALTHSHOT: return "healthshot"; break; 121 | case WEAPON_KNIFE_T: return !icons ? "knife" : "4"; break; 122 | case WEAPON_M4A1_SILENCER: return !icons ? "m4a1s" : "T"; break; 123 | case WEAPON_USP_SILENCER: return !icons ? "usp-s" : "G"; break; 124 | case WEAPON_CZ75A: return !icons ? "cz75a" : "I"; break; 125 | case WEAPON_REVOLVER: return !icons ? "r8" : "J";; break; 126 | case WEAPON_TAGRENADE: return "tag-grenade"; break; 127 | case WEAPON_FISTS: return "fists"; break; 128 | default: 129 | return !icons ? "default" : ""; 130 | break; 131 | } 132 | 133 | } 134 | 135 | const char * LocalPlayer::get_weapon_name2(int weaponId) 136 | { 137 | 138 | 139 | if (!this || weaponId < 0 || weaponId > 5035) 140 | return "error"; 141 | 142 | switch (weaponId) 143 | { 144 | case 0: return "glock-18"; break; 145 | case 1: return "usp-s"; break; 146 | case 2: return "p250"; break; 147 | case 3: return "five-seven"; break; 148 | case 4: return "dual-berets"; break; 149 | case 5: return "deagle"; break; 150 | case 6: return "r8"; break; 151 | case 7: return "ump-45"; break; 152 | case 8: return "mp-9"; break; 153 | case 9: return "mp-7"; break; 154 | case 10: return "mac-10"; break; 155 | case 11: return "famas"; break; 156 | case 12: return "Galil-Ar"; break; 157 | case 13: return "ak-47"; break; 158 | case 14: return "m4a1"; break; 159 | case 15: return "m4a1-s"; break; 160 | case 16: return "ssg-08"; break; 161 | case 17: return "awp"; break; 162 | case 18: return "scar-20"; break; 163 | case 19: return "G3SG1"; break; 164 | case 20: return "aug"; break; 165 | case 21: return "sg553"; break; 166 | } 167 | 168 | } 169 | 170 | int LocalPlayer::getWeaponNameInArray(int weaponId) 171 | { 172 | std::string buffer = get_weapon_name(weaponId); 173 | for (int i = 0; i < Config::get().skinItems; i++) 174 | { 175 | if (!stricmp(buffer.c_str(), get_weapon_name2(i))) 176 | { 177 | return i; 178 | } 179 | } 180 | return 0; 181 | } 182 | 183 | int LocalPlayer::getIdByName(std::string name) 184 | { 185 | const char* buff = name.c_str(); 186 | if (!strcmp(buff, "glock-18"))return 0; 187 | if (!strcmp(buff, "usp-s"))return 1; 188 | if (!strcmp(buff, "p250"))return 2; 189 | if (!strcmp(buff, "five-seven"))return 3; 190 | if (!strcmp(buff, "dual-berets"))return 4; 191 | if (!strcmp(buff, "deagle"))return 5; 192 | if (!strcmp(buff, "r8"))return 6; 193 | if (!strcmp(buff, "ump-45"))return 7; 194 | if (!strcmp(buff, "mp-9"))return 8; 195 | if (!strcmp(buff, "mp-7"))return 9; 196 | if (!strcmp(buff, "mac-10"))return 10; 197 | if (!strcmp(buff, "famas"))return 11; 198 | if (!strcmp(buff, "Galil-Ar"))return 12; 199 | if (!strcmp(buff, "ak-47"))return 13; 200 | if (!strcmp(buff, "m4a1"))return 14; 201 | if (!strcmp(buff, "m4a1-s"))return 15; 202 | if (!strcmp(buff, "ssg-08"))return 16; 203 | if (!strcmp(buff, "awp"))return 17; 204 | if (!strcmp(buff, "scar-20"))return 18; 205 | if (!strcmp(buff, "G3SG1"))return 19; 206 | if (!strcmp(buff, "aug"))return 20; 207 | if (!strcmp(buff, "sg553"))return 21; 208 | } 209 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/LocalPlayer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "vec3.h" 4 | #include 5 | #include "Singleton.h" 6 | 7 | class LocalPlayer : public Singleton 8 | { 9 | protected: 10 | int getHealth(); 11 | int getTeam(); 12 | int getFlags(); 13 | vec3 getOrigin(); 14 | vec3 GetviewOffset(); 15 | bool getDormant(); 16 | bool isScoping(); 17 | 18 | public: 19 | LocalPlayer() {}; 20 | LocalPlayer(uintptr_t addres) { base = addres; }; 21 | ~LocalPlayer() {}; 22 | int health; 23 | int team; 24 | int flags; 25 | int shotsFired; 26 | bool ownerC4; 27 | bool inScope; 28 | bool isDefusing; 29 | bool isDormant; 30 | vec3 origin; 31 | bool spotted = false; 32 | void Update(); 33 | vec3 viewOffset; 34 | vec3 getBonePos(int boneId, uintptr_t base); 35 | uintptr_t getBase() { return base; } 36 | int GetShotsFired(); 37 | std::string get_weapon_name(int weaponId, bool icons = false); 38 | const char* get_weapon_name2(int weaponId); 39 | int getWeaponNameInArray(int weaponId); 40 | int getIdByName(std::string name); 41 | protected: 42 | uintptr_t base; 43 | }; 44 | enum bones { 45 | head = 8, 46 | }; 47 | struct player_info_t { 48 | char __pad[0x10]; 49 | char name[32]; 50 | }; 51 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Memory.cpp: -------------------------------------------------------------------------------- 1 | #include "Memory.h" 2 | 3 | # if defined(_MSC_VER) 4 | # ifndef _CRT_SECURE_NO_DEPRECATE 5 | # define _CRT_SECURE_NO_DEPRECATE (1) 6 | # endif 7 | # pragma warning(disable : 4996) 8 | # endif 9 | 10 | 11 | DWORD memory::getProcessId(const char * name) 12 | { 13 | PROCESSENTRY32 pe32; 14 | pe32.dwSize = sizeof(PROCESSENTRY32); 15 | HANDLE hDump = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 16 | if (Process32First(hDump, &pe32)) 17 | { 18 | do { 19 | if (!stricmp(name, pe32.szExeFile)) 20 | { 21 | CloseHandle(hDump); 22 | return pe32.th32ProcessID; 23 | break;//dumb code 24 | } 25 | } while (Process32Next(hDump, &pe32)); 26 | } 27 | return 0; 28 | } 29 | uintptr_t memory::GetBase(const char * name) 30 | { 31 | MODULEENTRY32 me32; 32 | me32.dwSize = sizeof(MODULEENTRY32); 33 | HANDLE hDump = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, GlobalVars::get().pId); 34 | if (Module32First(hDump, &me32)) 35 | { 36 | do { 37 | if (!stricmp(name, me32.szModule)) 38 | { 39 | CloseHandle(hDump); 40 | return (uintptr_t)me32.modBaseAddr; 41 | break;//dumb code 42 | } 43 | } while (Module32Next(hDump, &me32)); 44 | } 45 | return -1337; 46 | } -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Memory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include 4 | #include "vec3.h" 5 | #include 6 | #include "GlobalVars.h" 7 | class memory : public Singleton 8 | { 9 | public: 10 | DWORD getProcessId(const char* name); 11 | uintptr_t GetBase(const char* name); 12 | template 13 | void write(uintptr_t addres, T buffer); 14 | template 15 | T read(uintptr_t addres); 16 | }; 17 | template 18 | inline void memory::write(uintptr_t addres, T buffer) 19 | { 20 | WriteProcessMemory(GlobalVars::get().csgo, LPVOID(addres), &buffer, sizeof(buffer), 0); 21 | } 22 | template 23 | inline T memory::read(uintptr_t addres) 24 | { 25 | T buffer; 26 | ReadProcessMemory(GlobalVars::get().csgo, LPVOID(addres), &buffer, sizeof(buffer), 0); 27 | return buffer; 28 | } 29 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Player.cpp: -------------------------------------------------------------------------------- 1 | #include "Player.h" 2 | #include "Memory.h" 3 | 4 | uintptr_t Player::getIGlow() 5 | { 6 | iGlow = memory::get().read(getBase() + GlobalVars::get().ofs.m_iGlowIndex); 7 | return iGlow; 8 | } 9 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Player.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "LocalPlayer.h" 3 | #include 4 | 5 | class Player : public LocalPlayer 6 | { 7 | public: 8 | Player() {}; 9 | Player(uintptr_t addr) { base = addr; }; 10 | vec3 origin2D; 11 | vec3 head2D; 12 | vec3 head2DByOrigin; 13 | vec3 head3DByOrigin; 14 | vec3 headPos3D; 15 | vec3 headPos2D; 16 | float height2D; 17 | float width2D; 18 | float distance; 19 | bool bestAimTarget = false; 20 | bool onFov = false; 21 | uintptr_t iGlow; 22 | uintptr_t getIGlow(); 23 | private: 24 | 25 | }; 26 | 27 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/RCS.cpp: -------------------------------------------------------------------------------- 1 | #include "RCS.h" 2 | #include "AimBot.h" 3 | void RCS::doRCS() 4 | { 5 | static vec3 oldAimPunchAngel = { 0,0,0 }; 6 | static uintptr_t dwClientState = memory::get().read(GlobalVars::get().engine + GlobalVars::get().ofs.dwClientState); 7 | vec3 aimPunchAngle; 8 | if (GlobalVars::get().localPlayer->GetShotsFired() > 1) 9 | { 10 | aimPunchAngle = memory::get().read(GlobalVars::get().localPlayer->getBase() + GlobalVars::get().ofs.m_aimPunchAngle); 11 | aimPunchAngle.x *= 2.05f; 12 | aimPunchAngle.y *= 2.05f; 13 | vec3 viewAngle = memory::get().read(dwClientState + GlobalVars::get().ofs.dwClientState_ViewAngles); 14 | viewAngle.x = viewAngle.x - (aimPunchAngle.x - oldAimPunchAngel.x); 15 | viewAngle.y = viewAngle.y - (aimPunchAngle.y - oldAimPunchAngel.y); 16 | oldAimPunchAngel = aimPunchAngle; 17 | AimBot::get().clamp(viewAngle.x, viewAngle.y); 18 | memory::get().write(dwClientState + GlobalVars::get().ofs.dwClientState_ViewAngles,viewAngle.x); 19 | memory::get().write(dwClientState + GlobalVars::get().ofs.dwClientState_ViewAngles + 0x4, viewAngle.y); 20 | } 21 | else { 22 | oldAimPunchAngel = { 0,0,0 }; 23 | } 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/RCS.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "GlobalVars.h" 3 | #include "vec3.h" 4 | #include "Singleton.h" 5 | class RCS : public Singleton 6 | { 7 | public: 8 | void doRCS(); 9 | private: 10 | }; 11 | 12 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/AimBot.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/AimBot.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Bunnyhope.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Bunnyhope.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Config.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Config.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.Build.CppClean.log: -------------------------------------------------------------------------------- 1 | c:\users\roman\source\repos\externalhack\externalhack\release\vc141.pdb 2 | c:\users\roman\source\repos\externalhack\externalhack\release\vec2.obj 3 | c:\users\roman\source\repos\externalhack\externalhack\release\singleton.obj 4 | c:\users\roman\source\repos\externalhack\externalhack\release\renderer.obj 5 | c:\users\roman\source\repos\externalhack\externalhack\release\rcs.obj 6 | c:\users\roman\source\repos\externalhack\externalhack\release\player.obj 7 | c:\users\roman\source\repos\externalhack\externalhack\release\menu.obj 8 | c:\users\roman\source\repos\externalhack\externalhack\release\memory.obj 9 | c:\users\roman\source\repos\externalhack\externalhack\release\localplayer.obj 10 | c:\users\roman\source\repos\externalhack\externalhack\release\glow.obj 11 | c:\users\roman\source\repos\externalhack\externalhack\release\globalvars.obj 12 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.obj 13 | c:\users\roman\source\repos\externalhack\externalhack\release\config.obj 14 | c:\users\roman\source\repos\externalhack\externalhack\release\bunnyhope.obj 15 | c:\users\roman\source\repos\externalhack\externalhack\release\aimbot.obj 16 | c:\users\roman\source\repos\externalhack\externalhack\release\imgui_widgets.obj 17 | c:\users\roman\source\repos\externalhack\externalhack\release\imgui_impl_win32.obj 18 | c:\users\roman\source\repos\externalhack\externalhack\release\imgui_impl_dx9.obj 19 | c:\users\roman\source\repos\externalhack\externalhack\release\imgui_draw.obj 20 | c:\users\roman\source\repos\externalhack\externalhack\release\imgui_demo.obj 21 | c:\users\roman\source\repos\externalhack\externalhack\release\imgui.obj 22 | c:\users\roman\source\repos\externalhack\externalhack\release\vec3.obj 23 | c:\users\roman\source\repos\externalhack\externalhack\release\triggerbot.obj 24 | c:\users\roman\source\repos\externalhack\externalhack\release\fakelag.obj 25 | c:\users\roman\source\repos\externalhack\externalhack\release\skinchanger.obj 26 | c:\users\roman\source\repos\externalhack\release\externalhack.exe 27 | c:\users\roman\source\repos\externalhack\release\externalhack.pdb 28 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.tlog\cl.command.1.tlog 29 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.tlog\cl.read.1.tlog 30 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.tlog\cl.write.1.tlog 31 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.tlog\link.command.1.tlog 32 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.tlog\link.read.1.tlog 33 | c:\users\roman\source\repos\externalhack\externalhack\release\externalhack.tlog\link.write.1.tlog 34 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.log: -------------------------------------------------------------------------------- 1 |  GlobalVars.cpp 2 | c:\users\roman\source\repos\externalhack\externalhack\globalvars.cpp(79): warning C4715: GlobalVars::findEntityByBaseInList: значение возвращается не при всех путях выполнения 3 | ExternalHack.vcxproj -> C:\Users\Roman\source\repos\ExternalHack\Release\ExternalHack.exe 4 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/CL.command.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.tlog/CL.command.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/CL.read.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.tlog/CL.read.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/CL.write.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.tlog/CL.write.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/ExternalHack.lastbuildstate: -------------------------------------------------------------------------------- 1 | #TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.17763.0 2 | Release|Win32|C:\Users\Roman\source\repos\ExternalHack\| 3 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/link.command.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.tlog/link.command.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/link.read.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.tlog/link.read.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/ExternalHack.tlog/link.write.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/ExternalHack.tlog/link.write.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/GlobalVars.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/GlobalVars.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Glow.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Glow.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/LocalPlayer.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/LocalPlayer.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Memory.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Memory.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Player.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Player.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/RCS.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/RCS.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Renderer.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Renderer.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Singleton.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Singleton.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/SkinChanger.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/SkinChanger.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/Triggerbot.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/Triggerbot.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/fakelag.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/fakelag.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/imgui.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/imgui.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/imgui_demo.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/imgui_demo.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/imgui_draw.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/imgui_draw.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/imgui_impl_dx9.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/imgui_impl_dx9.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/imgui_impl_win32.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/imgui_impl_win32.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/imgui_widgets.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/imgui_widgets.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/menu.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/menu.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/vc141.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/vc141.pdb -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/vec2.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/vec2.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Release/vec3.obj: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Release/vec3.obj -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Renderer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "GlobalVars.h" 3 | #include "Singleton.h" 4 | #include "vec3.h" 5 | #include "vec2.h" 6 | #include "menu.h" 7 | #include "../IMGUI/imgui.h" 8 | 9 | class Color 10 | { 11 | public: 12 | Color(); 13 | Color(int _r, int _g, int _b); 14 | Color(int _r, int _g, int _b, int _a); 15 | Color(float _r, float _g, float _b) : Color(_r, _g, _b, 1.0f) {} 16 | Color(float _r, float _g, float _b, float _a) 17 | : Color( 18 | static_cast(_r * 255.0f), 19 | static_cast(_g * 255.0f), 20 | static_cast(_b * 255.0f), 21 | static_cast(_a * 255.0f)) 22 | { 23 | } 24 | explicit Color(float* rgb) : Color(rgb[0], rgb[1], rgb[2], 1.0f) {} 25 | explicit Color(unsigned long argb) 26 | { 27 | _CColor[2] = (unsigned char)((argb & 0x000000FF) >> (0 * 8)); 28 | _CColor[1] = (unsigned char)((argb & 0x0000FF00) >> (1 * 8)); 29 | _CColor[0] = (unsigned char)((argb & 0x00FF0000) >> (2 * 8)); 30 | _CColor[3] = (unsigned char)((argb & 0xFF000000) >> (3 * 8)); 31 | } 32 | 33 | void SetRawColor(int color32); 34 | int GetRawColor() const; 35 | void SetColor(int _r, int _g, int _b, int _a = 0); 36 | void SetColor(float _r, float _g, float _b, float _a = 0); 37 | void GetColor(int &_r, int &_g, int &_b, int &_a) const; 38 | 39 | std::string GetNormalnijHexColor() const; 40 | 41 | int r() const { return _CColor[0]; } 42 | int g() const { return _CColor[1]; } 43 | int b() const { return _CColor[2]; } 44 | int a() const { return _CColor[3]; } 45 | 46 | unsigned char &operator[](int index) 47 | { 48 | return _CColor[index]; 49 | } 50 | const unsigned char &operator[](int index) const 51 | { 52 | return _CColor[index]; 53 | } 54 | 55 | bool operator==(const Color &rhs) const; 56 | bool operator!=(const Color &rhs) const; 57 | Color &operator=(const Color &rhs); 58 | 59 | static Color FromHSB(float hue, float saturation, float brightness) 60 | { 61 | float h = hue == 1.0f ? 0 : hue * 6.0f; 62 | float f = h - (int)h; 63 | float p = brightness * (1.0f - saturation); 64 | float q = brightness * (1.0f - saturation * f); 65 | float t = brightness * (1.0f - (saturation * (1.0f - f))); 66 | 67 | if (h < 1) 68 | { 69 | return Color( 70 | (unsigned char)(brightness * 255), 71 | (unsigned char)(t * 255), 72 | (unsigned char)(p * 255) 73 | ); 74 | } 75 | else if (h < 2) 76 | { 77 | return Color( 78 | (unsigned char)(q * 255), 79 | (unsigned char)(brightness * 255), 80 | (unsigned char)(p * 255) 81 | ); 82 | } 83 | else if (h < 3) 84 | { 85 | return Color( 86 | (unsigned char)(p * 255), 87 | (unsigned char)(brightness * 255), 88 | (unsigned char)(t * 255) 89 | ); 90 | } 91 | else if (h < 4) 92 | { 93 | return Color( 94 | (unsigned char)(p * 255), 95 | (unsigned char)(q * 255), 96 | (unsigned char)(brightness * 255) 97 | ); 98 | } 99 | else if (h < 5) 100 | { 101 | return Color( 102 | (unsigned char)(t * 255), 103 | (unsigned char)(p * 255), 104 | (unsigned char)(brightness * 255) 105 | ); 106 | } 107 | else 108 | { 109 | return Color( 110 | (unsigned char)(brightness * 255), 111 | (unsigned char)(p * 255), 112 | (unsigned char)(q * 255) 113 | ); 114 | } 115 | } 116 | 117 | static Color Black; 118 | static Color White; 119 | static Color Red; 120 | static Color Green; 121 | static Color Blue; 122 | 123 | private: 124 | unsigned char _CColor[4]; 125 | }; 126 | struct view_matrix_t { 127 | float* operator[ ](int index) { 128 | return matrix[index]; 129 | } 130 | float matrix[4][4]; 131 | }; 132 | class Renderer : public Singleton 133 | { 134 | public: 135 | Renderer() {}; 136 | ~Renderer() {}; 137 | void drawFrames(); 138 | void init() {if(!pDevice) pDevice = GlobalVars::get().pDevice; } 139 | 140 | bool world_to_screen(const vec3& screen_size, const vec3& pos, vec3& out, view_matrix_t matrix); 141 | private: 142 | void drawLine(vec2 pos, vec2 end, D3DCOLOR color); 143 | void DrawFilledRect(vec2 pos, vec2 size, D3DCOLOR color); 144 | void DrawRect(vec2 pos, vec2 size, D3DCOLOR color); 145 | void DrawCornerBox(vec2 pos, vec2 size, D3DCOLOR color, float thikness); 146 | void DrawSecondCornerBox(vec2 pos, vec2 size, D3DCOLOR color, float thikness); 147 | void DrawTriangle(vec2 pos, vec2 size, D3DCOLOR color, bool rainbow = false); 148 | void drawString(vec2 pos, vec2 size, const char* name); 149 | bool transformCoord(Player* player, view_matrix_t matrix); 150 | void doBoxEsp(Player* player); 151 | void scaleCoords(Player* player); 152 | void HealthEsp(Player* player); 153 | void drawImCircle(ImVec2 pos, float radius, ImU32 col , int segments = 16, bool filled = false); 154 | void drawImText(ImFont* font,ImVec2 pos, Color color, const char* txt, bool outline = true, float fontSize = 10.f); 155 | void drawImRect(ImVec2 from, ImVec2 size, Color color, bool filled = false); 156 | ImDrawList* backBuffer; 157 | struct vertex { 158 | float x, y, z, rhw; 159 | D3DCOLOR color; 160 | }; 161 | struct glow_t { 162 | uintptr_t base; 163 | float m_flRed; //0x0004 164 | float m_flGreen; //0x0008 165 | float m_flBlue; //0x000C 166 | float m_flAlpha; //0x0010 167 | uint8_t pad_0014[4]; //0x0014 168 | float m_flSomeFloat; //0x0018 169 | uint8_t pad_001C[4]; //0x001C 170 | float m_flAnotherFloat; //0x0020 171 | bool m_bRenderWhenOccluded; //0x0024 172 | bool m_bRenderWhenUnoccluded; //0x0025 173 | bool m_bFullBloomRender; //0x0026 174 | uint8_t pad_0027[5]; //0x0027 175 | int32_t m_nGlowStyle; //0x002C 176 | int32_t m_nSplitScreenSlot; //0x0030 177 | int32_t m_nNextFreeSlot; //0x0034 178 | }; 179 | ImU32 GetU32(Color _color) 180 | { 181 | return ((_color[3] & 0xff) << 24) + ((_color[2] & 0xff) << 16) + ((_color[1] & 0xff) << 8) 182 | + (_color[0] & 0xff); 183 | } 184 | protected: 185 | IDirect3DDevice9* pDevice; 186 | }; 187 | 188 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Singleton.cpp: -------------------------------------------------------------------------------- 1 | #include "Singleton.h" 2 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Singleton.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | template 3 | class Singleton 4 | { 5 | protected: 6 | Singleton() {}; 7 | ~Singleton() {}; 8 | public: 9 | static T& get() { 10 | static T inst{}; 11 | return inst; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/SkinChanger.cpp: -------------------------------------------------------------------------------- 1 | #include "SkinChanger.h" 2 | #include "Memory.h" 3 | #include 4 | void SkinChanger::doSkinChanger() 5 | { 6 | static int old[4] = { 0 }; 7 | uintptr_t clientState = memory::get().read(GlobalVars::get().engine + GlobalVars::get().ofs.dwClientState); 8 | for (int i = 0; i < 4; i++) { 9 | DWORD nigga = memory::get().read(GlobalVars::get().client + GlobalVars::get().ofs.dwEntityList + ((memory::get().read(GlobalVars::get().localPlayer->getBase() + GlobalVars::get().ofs.m_hMyWeapons + i * 0x4) & 0xFFF) - 1) * 0x10); 10 | short wpIndex = memory::get().read(nigga + GlobalVars::get().ofs.m_iItemDefinitionIndex); 11 | if (old[i] != wpIndex) 12 | { 13 | memory::get().write(clientState + GlobalVars::get().ofs.clientstate_delta_ticks, -1); 14 | } 15 | old[i] = wpIndex; 16 | if (wpIndex > 0 && wpIndex < 5035) 17 | { 18 | std::string customName; 19 | customName.resize(32); 20 | customName = getCustomNameById(wpIndex); 21 | memory::get().write(nigga + GlobalVars::get().ofs.m_iItemIDHigh, -1); 22 | memory::get().write(nigga + GlobalVars::get().ofs.m_nFallbackPaintKit, getSkinById(wpIndex));//fallbackpaintkit 23 | memory::get().write(nigga + GlobalVars::get().ofs.m_nFallbackSeed, 0.1f);//seed 24 | memory::get().write(nigga + GlobalVars::get().ofs.m_nFallbackStatTrak, 1337);//stattrack 25 | memory::get().write(nigga + GlobalVars::get().ofs.m_flFallbackWear, getWearById(wpIndex));//wear 26 | memory::get().write(nigga + GlobalVars::get().ofs.m_szCustomName, customName);//wear 27 | } 28 | } 29 | } 30 | 31 | 32 | 33 | int SkinChanger::getStatTrackById(int id) 34 | { 35 | int arrKey = LocalPlayer::get().getWeaponNameInArray(id); 36 | return Config::get().cfgWeapons[arrKey].statTrack; 37 | } 38 | 39 | int SkinChanger::getSkinById(int id) 40 | { 41 | int arrKey = LocalPlayer::get().getWeaponNameInArray(id); 42 | return Config::get().cfgWeapons[arrKey].skinId; 43 | } 44 | 45 | int SkinChanger::getIdOfSkinByComboList(int id) 46 | { 47 | switch (id) 48 | { 49 | case 0: 50 | return cherepa; 51 | case 1: 52 | return bloody_web; 53 | case 2: 54 | return fade; 55 | case 3: 56 | return blaze; 57 | case 4: 58 | return fireSerpent; 59 | case 5: 60 | return DLor; 61 | case 6: 62 | return Aquamarine; 63 | case 7: 64 | return HotRod; 65 | case 8: 66 | return Medusa; 67 | case 9: 68 | return Metallic_DDPAT; 69 | case 10: 70 | return NeoNoir; 71 | case 11: 72 | return BOOM; 73 | case 12: 74 | return Emerald; 75 | case 13: 76 | return Asiimov; 77 | default: 78 | break; 79 | } 80 | } 81 | 82 | float SkinChanger::getWearById(int id) 83 | { 84 | int arrKey = LocalPlayer::get().getWeaponNameInArray(id); 85 | return Config::get().cfgWeapons[arrKey].wear; 86 | } 87 | 88 | std::string SkinChanger::getCustomNameById(int id) 89 | { 90 | int arrKey = LocalPlayer::get().getWeaponNameInArray(id); 91 | return Config::get().cfgWeapons[arrKey].customName; 92 | } 93 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/SkinChanger.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include 4 | enum SkinList { 5 | cherepa = 11, 6 | bloody_web = 12, 7 | blaze = 37, 8 | fade, 9 | BOOM = 174, 10 | Emerald = 196, 11 | fireSerpent = 180, 12 | Asiimov = 279, 13 | DLor = 344, 14 | Aquamarine = 353, 15 | HotRod = 445, 16 | Medusa, 17 | Metallic_DDPAT = 449, 18 | NeoNoir = 653, 19 | }; 20 | 21 | class SkinChanger : public Singleton 22 | { 23 | public: 24 | void doSkinChanger(); 25 | int getStatTrackById(int id); 26 | int getSkinById(int id); 27 | int getIdOfSkinByComboList(int id); 28 | float getWearById(int id); 29 | std::string getCustomNameById(int id); 30 | private: 31 | }; 32 | 33 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Triggerbot.cpp: -------------------------------------------------------------------------------- 1 | #include "Triggerbot.h" 2 | #include "Glow.h" 3 | #include 4 | #include 5 | void Triggerbot::doTriggerbot() 6 | { 7 | if (canShoot()) 8 | { 9 | if (!Config::get().safeTrigger) { 10 | static DWORD time = GetTickCount(); 11 | if (GetTickCount() - time >= Config::get().delayBetweenShots) { 12 | time = GetTickCount(); 13 | memory::get().write(GlobalVars::get().client + GlobalVars::get().ofs.dwForceAttack, 5); 14 | std::this_thread::sleep_for(std::chrono::milliseconds(5)); 15 | memory::get().write(GlobalVars::get().client + GlobalVars::get().ofs.dwForceAttack, 4); 16 | } 17 | } 18 | else { 19 | static DWORD time = GetTickCount(); 20 | if (GetTickCount() - time >= Config::get().delayBetweenShots) { 21 | time = GetTickCount(); 22 | mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); 23 | std::this_thread::sleep_for(std::chrono::milliseconds(2)); 24 | mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); 25 | } 26 | } 27 | } 28 | } 29 | 30 | 31 | bool Triggerbot::canShoot() 32 | { 33 | int EntityOnCrosshair = memory::get().read(GlobalVars::get().localPlayer->getBase() + GlobalVars::get().ofs.m_iCrosshairId); 34 | if (EntityOnCrosshair > 0 && EntityOnCrosshair < 64) 35 | { 36 | Player* currEntity =new Player( memory::get().read(GlobalVars::get().client + GlobalVars::get().ofs.dwEntityList + (EntityOnCrosshair - 1) * 0x10));//new instead globalVars cuz has crashes 37 | currEntity->Update(); 38 | if (currEntity != nullptr && currEntity != NULL) { 39 | if (currEntity->team != memory::get().read(GlobalVars::get().localPlayer->getBase() + GlobalVars::get().ofs.m_iTeam) && currEntity->health > 0) 40 | { 41 | delete currEntity; 42 | return true; 43 | } 44 | } 45 | delete currEntity; 46 | return false; 47 | } 48 | return false; 49 | } 50 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Triggerbot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include "GlobalVars.h" 4 | class Triggerbot : public Singleton 5 | { 6 | public: 7 | void doTriggerbot(); 8 | bool canShoot(); 9 | private: 10 | }; 11 | 12 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/Untitled1.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/Untitled1.ttf -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/fakelag.cpp: -------------------------------------------------------------------------------- 1 | #include "fakelag.h" 2 | 3 | void fakelag::doFakeLag() 4 | { 5 | clientState = memory::get().read(GlobalVars::get().engine + GlobalVars::get().ofs.dwClientState); 6 | choked_packets = memory::get().read(clientState + GlobalVars::get().ofs.clientstate_choked_commands); 7 | if (choked_packets >= Config::get().factor) 8 | { 9 | memory::get().write(GlobalVars::get().engine + GlobalVars::get().ofs.dwbSendPackets, true); 10 | } 11 | else { 12 | memory::get().write(GlobalVars::get().engine + GlobalVars::get().ofs.dwbSendPackets, false); 13 | } 14 | } 15 | 16 | void fakelag::shutdown() 17 | { 18 | memory::get().write(GlobalVars::get().engine + GlobalVars::get().ofs.dwbSendPackets, true); 19 | } 20 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/fakelag.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include 4 | #include "Memory.h" 5 | class fakelag : public Singleton 6 | { 7 | public: 8 | void doFakeLag(); 9 | void shutdown(); 10 | int getChockedPackets() { return choked_packets; } 11 | private: 12 | uintptr_t clientState = 0; 13 | int choked_packets = 0; 14 | }; 15 | 16 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/imgui.ini: -------------------------------------------------------------------------------- 1 | [Window][Debug##Default] 2 | Pos=60,60 3 | Size=400,400 4 | Collapsed=0 5 | 6 | [Window][Menu] 7 | Pos=387,76 8 | Size=640,480 9 | Collapsed=0 10 | 11 | [Window][second] 12 | Pos=343,757 13 | Size=640,120 14 | Collapsed=0 15 | 16 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/menu.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | #include "GlobalVars.h" 4 | #include "../IMGUI/imgui.h" 5 | #include "Config.h" 6 | #include "../IMGUI/imgui_impl_dx9.h" 7 | #include "../IMGUI/imgui_impl_win32.h" 8 | #include 9 | class menu : public Singleton 10 | { 11 | public: 12 | void init(); 13 | void drawMainMenu(); 14 | void endMenuScene(); 15 | void setStyles(); 16 | //LRESULT WINAPI WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); 17 | bool showMenu = false; 18 | WNDPROC wndproc_orig; 19 | int sizeX = 640; 20 | int sizeY = 480; 21 | int currTab = 1; 22 | void drawAimbotTab(); 23 | void drawAimbotTab2(); 24 | ImFont* fTabs; 25 | ImFont* weaponTabs; 26 | ImFont* defFont; 27 | ImFont* espFont; 28 | ImDrawList* list; 29 | void drawVisualSubTab(); 30 | void drawMiscTab(); 31 | void drawMiscTab2(); 32 | void drawCFGTab(); 33 | void drawCFGTab2(); 34 | void drawVisualSubTab2(); 35 | ImDrawList* getDrawList() { return list; }; 36 | int menuType = 1; 37 | private: 38 | bool isInit = false; 39 | 40 | 41 | }; 42 | 43 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/undefeated.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/undefeated.ttf -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/vec2.cpp: -------------------------------------------------------------------------------- 1 | #include "vec2.h" 2 | #include 3 | vec2::vec2(int a, int b) 4 | { 5 | this->x = a; this->y = b; 6 | } 7 | 8 | vec2::vec2(float a, float b) 9 | { 10 | this->x = a; this->y = b; 11 | } 12 | 13 | vec2 vec2::operator+(vec2 a) 14 | { 15 | return vec2(this->x + a.x, this->y + a.y); 16 | } 17 | 18 | vec2 vec2::operator-(vec2 a) 19 | { 20 | return vec2(this->x - a.x, this->y - a.y); 21 | } 22 | 23 | vec2 vec2::operator*(vec2 a) 24 | { 25 | return vec2(this->x * a.x, this->y * a.y); 26 | } 27 | 28 | vec2 vec2::operator/(vec2 a) 29 | { 30 | return vec2(this->x / a.x, this->y / a.y); 31 | } 32 | 33 | vec2 vec2::operator+=(vec2 a) 34 | { 35 | return vec2(this->x + a.x, this->y + a.y); 36 | } 37 | 38 | vec2 vec2::operator-=(vec2 a) 39 | { 40 | return vec2(this->x - a.x, this->y - a.y); 41 | } 42 | 43 | vec2 vec2::operator-=(int x) 44 | { 45 | return vec2(this->x - x, this->y - x); 46 | } 47 | 48 | vec2 vec2::operator+=(int x) 49 | { 50 | return vec2(this->x + x, this->y + x); 51 | } 52 | 53 | vec2 vec2::operator+(int x) 54 | { 55 | return vec2(this->x + x, this->y + x); 56 | } 57 | 58 | vec2 vec2::operator-(int x) 59 | { 60 | return vec2(this->x - x, this->y - x); 61 | } 62 | 63 | vec2 vec2::operator/(float a) 64 | { 65 | return vec2(this->x / a, this->y / a); 66 | } 67 | 68 | float vec2::length() 69 | { 70 | return(sqrt(pow(this->x, 2.f) + pow(this->y, 2.f))); 71 | } 72 | 73 | 74 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/vec2.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | class vec2 3 | { 4 | public: 5 | vec2() {}; 6 | ~vec2() {}; 7 | vec2(int a, int b); 8 | vec2(float a, float b); 9 | vec2 operator+(vec2 a); 10 | vec2 operator-(vec2 a); 11 | vec2 operator*(vec2 a); 12 | vec2 operator/(vec2 a); 13 | vec2 operator+=(vec2 a); 14 | vec2 operator-=(vec2 a); 15 | vec2 operator-=(int x); 16 | vec2 operator+=(int x); 17 | vec2 operator+(int x); 18 | vec2 operator-(int x); 19 | vec2 operator/(float a); 20 | float length(); 21 | float x = 0; 22 | float y = 0; 23 | }; 24 | 25 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/vec3.cpp: -------------------------------------------------------------------------------- 1 | #include "vec3.h" 2 | #include 3 | float vec3::length() 4 | { 5 | return sqrt(pow(this->x, 2) + pow(this->y, 2) + pow(this->z, 2)); 6 | } 7 | 8 | float vec3::distance(vec3 f, vec3 f1) 9 | { 10 | return sqrt(pow(f1.x - f.x, 2) + pow(f1.y - f.y, 2) + pow(f1.z - f.z, 2)); 11 | } 12 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/vec3.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "Singleton.h" 3 | class vec3 : public Singleton 4 | { 5 | public: 6 | vec3(float x, float y, float z) { this->x = x; this->y = y; this->z = z; }; 7 | vec3() { }; 8 | float x, y, z; 9 | float length(); 10 | float distance(vec3 f, vec3 f1); 11 | vec3 operator+(vec3 a) 12 | { 13 | this->x += a.x; 14 | this->y += a.y; 15 | this->z += a.z; 16 | return *this; 17 | } 18 | vec3 operator-(vec3 a) 19 | { 20 | this->x -= a.x; 21 | this->y -= a.y; 22 | this->z -= a.z; 23 | return *this; 24 | } 25 | private: 26 | }; 27 | 28 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/vgafixr.fon: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/vgafixr.fon -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/ExternalHack.log: -------------------------------------------------------------------------------- 1 |  imgui.cpp 2 | imgui_demo.cpp 3 | imgui_draw.cpp 4 | imgui_impl_dx9.cpp 5 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/CL.command.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/CL.command.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/CL.read.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/CL.read.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/CL.write.1.tlog: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/CL.write.1.tlog -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/ExternalHack.lastbuildstate: -------------------------------------------------------------------------------- 1 | #TargetFrameworkVersion=v4.0:PlatformToolSet=v141:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit:WindowsTargetPlatformVersion=10.0.17763.0 2 | Debug|x64|C:\Users\Roman\source\repos\ExternalHack\| 3 | -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/unsuccessfulbuild: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/x64/Debug/ExternalHack.tlog/unsuccessfulbuild -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/vc141.idb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/x64/Debug/vc141.idb -------------------------------------------------------------------------------- /ExternalHack/ExternalHack/x64/Debug/vc141.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/ExternalHack/x64/Debug/vc141.pdb -------------------------------------------------------------------------------- /ExternalHack/IMGUI/imconfig.h: -------------------------------------------------------------------------------- 1 | //----------------------------------------------------------------------------- 2 | // COMPILE-TIME OPTIONS FOR DEAR IMGUI 3 | // Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure. 4 | // You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions. 5 | //----------------------------------------------------------------------------- 6 | // A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/branch with your modifications to imconfig.h) 7 | // B) or add configuration directives in your own file and compile with #define IMGUI_USER_CONFIG "myfilename.h" 8 | // If you do so you need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include 9 | // the imgui*.cpp files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures. 10 | // Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts. 11 | // Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using. 12 | //----------------------------------------------------------------------------- 13 | 14 | #pragma once 15 | 16 | //---- Define assertion handler. Defaults to calling assert(). 17 | // If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement. 18 | //#define IM_ASSERT(_EXPR) MyAssert(_EXPR) 19 | //#define IM_ASSERT(_EXPR) ((void)(_EXPR)) // Disable asserts 20 | 21 | //---- Define attributes of all API symbols declarations, e.g. for DLL under Windows 22 | // Using dear imgui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility. 23 | //#define IMGUI_API __declspec( dllexport ) 24 | //#define IMGUI_API __declspec( dllimport ) 25 | 26 | //---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names. 27 | //#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS 28 | 29 | //---- Disable all of Dear ImGui or don't implement standard windows. 30 | // It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp. 31 | //#define IMGUI_DISABLE // Disable everything: all headers and source files will be empty. 32 | //#define IMGUI_DISABLE_DEMO_WINDOWS // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended. 33 | //#define IMGUI_DISABLE_METRICS_WINDOW // Disable debug/metrics window: ShowMetricsWindow() will be empty. 34 | 35 | //---- Don't implement some functions to reduce linkage requirements. 36 | //#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. 37 | //#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] Don't implement default IME handler. Won't use and link with ImmGetContext/ImmSetCompositionWindow. 38 | //#define IMGUI_DISABLE_WIN32_FUNCTIONS // [Win32] Won't use and link with any Win32 function (clipboard, ime). 39 | //#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default). 40 | //#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf) 41 | //#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself. 42 | //#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function. 43 | //#define IMGUI_DISABLE_DEFAULT_ALLOCATORS // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions(). 44 | 45 | //---- Include imgui_user.h at the end of imgui.h as a convenience 46 | //#define IMGUI_INCLUDE_IMGUI_USER_H 47 | 48 | //---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another) 49 | //#define IMGUI_USE_BGRA_PACKED_COLOR 50 | 51 | //---- Use 32-bit for ImWchar (default is 16-bit) to support full unicode code points. 52 | //#define IMGUI_USE_WCHAR32 53 | 54 | //---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version 55 | // By default the embedded implementations are declared static and not available outside of imgui cpp files. 56 | //#define IMGUI_STB_TRUETYPE_FILENAME "my_folder/stb_truetype.h" 57 | //#define IMGUI_STB_RECT_PACK_FILENAME "my_folder/stb_rect_pack.h" 58 | //#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION 59 | //#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION 60 | 61 | //---- Unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined, use the much faster STB sprintf library implementation of vsnprintf instead of the one from the default C library. 62 | // Note that stb_sprintf.h is meant to be provided by the user and available in the include path at compile time. Also, the compatibility checks of the arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf. 63 | // #define IMGUI_USE_STB_SPRINTF 64 | 65 | //---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4. 66 | // This will be inlined as part of ImVec2 and ImVec4 class declarations. 67 | /* 68 | #define IM_VEC2_CLASS_EXTRA \ 69 | ImVec2(const MyVec2& f) { x = f.x; y = f.y; } \ 70 | operator MyVec2() const { return MyVec2(x,y); } 71 | 72 | #define IM_VEC4_CLASS_EXTRA \ 73 | ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; } \ 74 | operator MyVec4() const { return MyVec4(x,y,z,w); } 75 | */ 76 | 77 | //---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices. 78 | // Your renderer back-end will need to support it (most example renderer back-ends support both 16/32-bit indices). 79 | // Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer. 80 | // Read about ImGuiBackendFlags_RendererHasVtxOffset for details. 81 | //#define ImDrawIdx unsigned int 82 | 83 | //---- Override ImDrawCallback signature (will need to modify renderer back-ends accordingly) 84 | //struct ImDrawList; 85 | //struct ImDrawCmd; 86 | //typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data); 87 | //#define ImDrawCallback MyImDrawCallback 88 | 89 | //---- Debug Tools: Macro to break in Debugger 90 | // (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.) 91 | //#define IM_DEBUG_BREAK IM_ASSERT(0) 92 | //#define IM_DEBUG_BREAK __debugbreak() 93 | 94 | //---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(), 95 | // (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.) 96 | // This adds a small runtime cost which is why it is not enabled by default. 97 | //#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX 98 | 99 | //---- Debug Tools: Enable slower asserts 100 | //#define IMGUI_DEBUG_PARANOID 101 | 102 | //---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files. 103 | /* 104 | namespace ImGui 105 | { 106 | void MyFunction(const char* name, const MyMatrix44& v); 107 | } 108 | */ 109 | -------------------------------------------------------------------------------- /ExternalHack/IMGUI/imgui_impl_dx9.cpp: -------------------------------------------------------------------------------- 1 | // dear imgui: Renderer for DirectX9 2 | // This needs to be used along with a Platform Binding (e.g. Win32) 3 | 4 | // Implemented features: 5 | // [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID in imgui.cpp. 6 | 7 | // You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this. 8 | // If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp. 9 | // https://github.com/ocornut/imgui 10 | 11 | // CHANGELOG 12 | // (minor and older changes stripped away, please see git history for details) 13 | // 2019-01-16: Misc: Disabled fog before drawing UI's. Fixes issue #2288. 14 | // 2018-11-30: Misc: Setting up io.BackendRendererName so it can be displayed in the About Window. 15 | // 2018-06-08: Misc: Extracted imgui_impl_dx9.cpp/.h away from the old combined DX9+Win32 example. 16 | // 2018-06-08: DirectX9: Use draw_data->DisplayPos and draw_data->DisplaySize to setup projection matrix and clipping rectangle. 17 | // 2018-05-07: Render: Saving/restoring Transform because they don't seem to be included in the StateBlock. Setting shading mode to Gouraud. 18 | // 2018-02-16: Misc: Obsoleted the io.RenderDrawListsFn callback and exposed ImGui_ImplDX9_RenderDrawData() in the .h file so you can call it yourself. 19 | // 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves. 20 | 21 | #include "../IMGUI/imgui.h" 22 | #include "imgui_impl_dx9.h" 23 | 24 | // DirectX 25 | #include 26 | #define DIRECTINPUT_VERSION 0x0800 27 | #include 28 | 29 | // DirectX data 30 | static LPDIRECT3DDEVICE9 g_pd3dDevice = NULL; 31 | static LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; 32 | static LPDIRECT3DINDEXBUFFER9 g_pIB = NULL; 33 | static LPDIRECT3DTEXTURE9 g_FontTexture = NULL; 34 | static int g_VertexBufferSize = 5000, g_IndexBufferSize = 10000; 35 | 36 | struct CUSTOMVERTEX 37 | { 38 | float pos[3]; 39 | D3DCOLOR col; 40 | float uv[2]; 41 | }; 42 | #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1) 43 | 44 | // Render function. 45 | // (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop) 46 | void ImGui_ImplDX9_RenderDrawData(ImDrawData* draw_data) 47 | { 48 | // Avoid rendering when minimized 49 | if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f) 50 | return; 51 | 52 | // Create and grow buffers if needed 53 | if (!g_pVB || g_VertexBufferSize < draw_data->TotalVtxCount) 54 | { 55 | if (g_pVB) { g_pVB->Release(); g_pVB = NULL; } 56 | g_VertexBufferSize = draw_data->TotalVtxCount + 5000; 57 | if (g_pd3dDevice->CreateVertexBuffer(g_VertexBufferSize * sizeof(CUSTOMVERTEX), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &g_pVB, NULL) < 0) 58 | return; 59 | } 60 | if (!g_pIB || g_IndexBufferSize < draw_data->TotalIdxCount) 61 | { 62 | if (g_pIB) { g_pIB->Release(); g_pIB = NULL; } 63 | g_IndexBufferSize = draw_data->TotalIdxCount + 10000; 64 | if (g_pd3dDevice->CreateIndexBuffer(g_IndexBufferSize * sizeof(ImDrawIdx), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, sizeof(ImDrawIdx) == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32, D3DPOOL_DEFAULT, &g_pIB, NULL) < 0) 65 | return; 66 | } 67 | 68 | // Backup the DX9 state 69 | IDirect3DStateBlock9* d3d9_state_block = NULL; 70 | if (g_pd3dDevice->CreateStateBlock(D3DSBT_PIXELSTATE, &d3d9_state_block) < 0) 71 | return; 72 | 73 | // Backup the DX9 transform (DX9 documentation suggests that it is included in the StateBlock but it doesn't appear to) 74 | D3DMATRIX last_world, last_view, last_projection; 75 | g_pd3dDevice->GetTransform(D3DTS_WORLD, &last_world); 76 | g_pd3dDevice->GetTransform(D3DTS_VIEW, &last_view); 77 | g_pd3dDevice->GetTransform(D3DTS_PROJECTION, &last_projection); 78 | 79 | // Copy and convert all vertices into a single contiguous buffer, convert colors to DX9 default format. 80 | // FIXME-OPT: This is a waste of resource, the ideal is to use imconfig.h and 81 | // 1) to avoid repacking colors: #define IMGUI_USE_BGRA_PACKED_COLOR 82 | // 2) to avoid repacking vertices: #define IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT struct ImDrawVert { ImVec2 pos; float z; ImU32 col; ImVec2 uv; } 83 | CUSTOMVERTEX* vtx_dst; 84 | ImDrawIdx* idx_dst; 85 | if (g_pVB->Lock(0, (UINT)(draw_data->TotalVtxCount * sizeof(CUSTOMVERTEX)), (void**)&vtx_dst, D3DLOCK_DISCARD) < 0) 86 | return; 87 | if (g_pIB->Lock(0, (UINT)(draw_data->TotalIdxCount * sizeof(ImDrawIdx)), (void**)&idx_dst, D3DLOCK_DISCARD) < 0) 88 | return; 89 | for (int n = 0; n < draw_data->CmdListsCount; n++) 90 | { 91 | const ImDrawList* cmd_list = draw_data->CmdLists[n]; 92 | const ImDrawVert* vtx_src = cmd_list->VtxBuffer.Data; 93 | for (int i = 0; i < cmd_list->VtxBuffer.Size; i++) 94 | { 95 | vtx_dst->pos[0] = vtx_src->pos.x; 96 | vtx_dst->pos[1] = vtx_src->pos.y; 97 | vtx_dst->pos[2] = 0.0f; 98 | vtx_dst->col = (vtx_src->col & 0xFF00FF00) | ((vtx_src->col & 0xFF0000) >> 16) | ((vtx_src->col & 0xFF) << 16); // RGBA --> ARGB for DirectX9 99 | vtx_dst->uv[0] = vtx_src->uv.x; 100 | vtx_dst->uv[1] = vtx_src->uv.y; 101 | vtx_dst++; 102 | vtx_src++; 103 | } 104 | memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx)); 105 | idx_dst += cmd_list->IdxBuffer.Size; 106 | } 107 | g_pVB->Unlock(); 108 | g_pIB->Unlock(); 109 | g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX)); 110 | g_pd3dDevice->SetIndices(g_pIB); 111 | g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX); 112 | 113 | // Setup viewport 114 | D3DVIEWPORT9 vp; 115 | vp.X = vp.Y = 0; 116 | vp.Width = (DWORD)draw_data->DisplaySize.x; 117 | vp.Height = (DWORD)draw_data->DisplaySize.y; 118 | vp.MinZ = 0.0f; 119 | vp.MaxZ = 1.0f; 120 | g_pd3dDevice->SetViewport(&vp); 121 | 122 | // Setup render state: fixed-pipeline, alpha-blending, no face culling, no depth testing, shade mode (for gradient) 123 | g_pd3dDevice->SetPixelShader(NULL); 124 | g_pd3dDevice->SetVertexShader(NULL); 125 | g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); 126 | g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, false); 127 | g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, false); 128 | g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true); 129 | g_pd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, false); 130 | g_pd3dDevice->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD); 131 | g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); 132 | g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); 133 | g_pd3dDevice->SetRenderState(D3DRS_SCISSORTESTENABLE, true); 134 | g_pd3dDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD); 135 | g_pd3dDevice->SetRenderState(D3DRS_FOGENABLE, false); 136 | g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE); 137 | g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE); 138 | g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE); 139 | g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE); 140 | g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE); 141 | g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE); 142 | g_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); 143 | g_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); 144 | 145 | // Setup orthographic projection matrix 146 | // Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right). 147 | // Being agnostic of whether or can be used, we aren't relying on D3DXMatrixIdentity()/D3DXMatrixOrthoOffCenterLH() or DirectX::XMMatrixIdentity()/DirectX::XMMatrixOrthographicOffCenterLH() 148 | { 149 | float L = draw_data->DisplayPos.x + 0.5f; 150 | float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x + 0.5f; 151 | float T = draw_data->DisplayPos.y + 0.5f; 152 | float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y + 0.5f; 153 | D3DMATRIX mat_identity = { { { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f } } }; 154 | D3DMATRIX mat_projection = 155 | { { { 156 | 2.0f/(R-L), 0.0f, 0.0f, 0.0f, 157 | 0.0f, 2.0f/(T-B), 0.0f, 0.0f, 158 | 0.0f, 0.0f, 0.5f, 0.0f, 159 | (L+R)/(L-R), (T+B)/(B-T), 0.5f, 1.0f 160 | } } }; 161 | g_pd3dDevice->SetTransform(D3DTS_WORLD, &mat_identity); 162 | g_pd3dDevice->SetTransform(D3DTS_VIEW, &mat_identity); 163 | g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &mat_projection); 164 | } 165 | 166 | // Render command lists 167 | int vtx_offset = 0; 168 | int idx_offset = 0; 169 | ImVec2 clip_off = draw_data->DisplayPos; 170 | for (int n = 0; n < draw_data->CmdListsCount; n++) 171 | { 172 | const ImDrawList* cmd_list = draw_data->CmdLists[n]; 173 | for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) 174 | { 175 | const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; 176 | if (pcmd->UserCallback) 177 | { 178 | pcmd->UserCallback(cmd_list, pcmd); 179 | } 180 | else 181 | { 182 | const RECT r = { (LONG)(pcmd->ClipRect.x - clip_off.x), (LONG)(pcmd->ClipRect.y - clip_off.y), (LONG)(pcmd->ClipRect.z - clip_off.x), (LONG)(pcmd->ClipRect.w - clip_off.y) }; 183 | const LPDIRECT3DTEXTURE9 texture = (LPDIRECT3DTEXTURE9)pcmd->TextureId; 184 | g_pd3dDevice->SetTexture(0, texture); 185 | g_pd3dDevice->SetScissorRect(&r); 186 | g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, vtx_offset, 0, (UINT)cmd_list->VtxBuffer.Size, idx_offset, pcmd->ElemCount/3); 187 | } 188 | idx_offset += pcmd->ElemCount; 189 | } 190 | vtx_offset += cmd_list->VtxBuffer.Size; 191 | } 192 | 193 | // Restore the DX9 transform 194 | g_pd3dDevice->SetTransform(D3DTS_WORLD, &last_world); 195 | g_pd3dDevice->SetTransform(D3DTS_VIEW, &last_view); 196 | g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &last_projection); 197 | 198 | // Restore the DX9 state 199 | d3d9_state_block->Apply(); 200 | d3d9_state_block->Release(); 201 | } 202 | 203 | bool ImGui_ImplDX9_Init(IDirect3DDevice9* device) 204 | { 205 | ImGuiIO& io = ImGui::GetIO(); 206 | io.BackendRendererName = "imgui_impl_dx9"; 207 | 208 | g_pd3dDevice = device; 209 | return true; 210 | } 211 | 212 | void ImGui_ImplDX9_Shutdown() 213 | { 214 | ImGui_ImplDX9_InvalidateDeviceObjects(); 215 | g_pd3dDevice = NULL; 216 | } 217 | 218 | static bool ImGui_ImplDX9_CreateFontsTexture() 219 | { 220 | // Build texture atlas 221 | ImGuiIO& io = ImGui::GetIO(); 222 | unsigned char* pixels; 223 | int width, height, bytes_per_pixel; 224 | io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height, &bytes_per_pixel); 225 | 226 | // Upload texture to graphics system 227 | g_FontTexture = NULL; 228 | if (g_pd3dDevice->CreateTexture(width, height, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_FontTexture, NULL) < 0) 229 | return false; 230 | D3DLOCKED_RECT tex_locked_rect; 231 | if (g_FontTexture->LockRect(0, &tex_locked_rect, NULL, 0) != D3D_OK) 232 | return false; 233 | for (int y = 0; y < height; y++) 234 | memcpy((unsigned char *)tex_locked_rect.pBits + tex_locked_rect.Pitch * y, pixels + (width * bytes_per_pixel) * y, (width * bytes_per_pixel)); 235 | g_FontTexture->UnlockRect(0); 236 | 237 | // Store our identifier 238 | io.Fonts->TexID = (ImTextureID)g_FontTexture; 239 | 240 | return true; 241 | } 242 | 243 | bool ImGui_ImplDX9_CreateDeviceObjects() 244 | { 245 | if (!g_pd3dDevice) 246 | return false; 247 | if (!ImGui_ImplDX9_CreateFontsTexture()) 248 | return false; 249 | return true; 250 | } 251 | 252 | void ImGui_ImplDX9_InvalidateDeviceObjects() 253 | { 254 | if (!g_pd3dDevice) 255 | return; 256 | if (g_pVB) 257 | { 258 | g_pVB->Release(); 259 | g_pVB = NULL; 260 | } 261 | if (g_pIB) 262 | { 263 | g_pIB->Release(); 264 | g_pIB = NULL; 265 | } 266 | 267 | // At this point note that we set ImGui::GetIO().Fonts->TexID to be == g_FontTexture, so clear both. 268 | ImGuiIO& io = ImGui::GetIO(); 269 | IM_ASSERT(g_FontTexture == io.Fonts->TexID); 270 | if (g_FontTexture) 271 | g_FontTexture->Release(); 272 | g_FontTexture = NULL; 273 | io.Fonts->TexID = NULL; 274 | } 275 | 276 | void ImGui_ImplDX9_NewFrame() 277 | { 278 | if (!g_FontTexture) 279 | ImGui_ImplDX9_CreateDeviceObjects(); 280 | } 281 | -------------------------------------------------------------------------------- /ExternalHack/IMGUI/imgui_impl_dx9.h: -------------------------------------------------------------------------------- 1 | // dear imgui: Renderer for DirectX9 2 | // This needs to be used along with a Platform Binding (e.g. Win32) 3 | 4 | // Implemented features: 5 | // [X] Renderer: User texture binding. Use 'LPDIRECT3DTEXTURE9' as ImTextureID. Read the FAQ about ImTextureID in imgui.cpp. 6 | 7 | // You can copy and use unmodified imgui_impl_* files in your project. See main.cpp for an example of using this. 8 | // If you are new to dear imgui, read examples/README.txt and read the documentation at the top of imgui.cpp. 9 | // https://github.com/ocornut/imgui 10 | 11 | #pragma once 12 | 13 | struct IDirect3DDevice9; 14 | 15 | IMGUI_IMPL_API bool ImGui_ImplDX9_Init(IDirect3DDevice9* device); 16 | IMGUI_IMPL_API void ImGui_ImplDX9_Shutdown(); 17 | IMGUI_IMPL_API void ImGui_ImplDX9_NewFrame(); 18 | IMGUI_IMPL_API void ImGui_ImplDX9_RenderDrawData(ImDrawData* draw_data); 19 | 20 | // Use if you want to reset your rendering device without losing ImGui state. 21 | IMGUI_IMPL_API void ImGui_ImplDX9_InvalidateDeviceObjects(); 22 | IMGUI_IMPL_API bool ImGui_ImplDX9_CreateDeviceObjects(); 23 | -------------------------------------------------------------------------------- /ExternalHack/IMGUI/imgui_impl_win32.cpp: -------------------------------------------------------------------------------- 1 | // dear imgui: Platform Binding for Windows (standard windows API for 32 and 64 bits applications) 2 | // This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..) 3 | 4 | // Implemented features: 5 | // [X] Platform: Clipboard support (for Win32 this is actually part of core imgui) 6 | // [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. 7 | // [X] Platform: Keyboard arrays indexed using VK_* Virtual Key Codes, e.g. ImGui::IsKeyPressed(VK_SPACE). 8 | // [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'. 9 | 10 | #include "imgui.h" 11 | #include "imgui_impl_win32.h" 12 | #ifndef WIN32_LEAN_AND_MEAN 13 | #define WIN32_LEAN_AND_MEAN 14 | #endif 15 | #include 16 | #include 17 | #include 18 | 19 | // CHANGELOG 20 | // (minor and older changes stripped away, please see git history for details) 21 | // 2019-01-17: Misc: Using GetForegroundWindow()+IsChild() instead of GetActiveWindow() to be compatible with windows created in a different thread or parent. 22 | // 2019-01-17: Inputs: Added support for mouse buttons 4 and 5 via WM_XBUTTON* messages. 23 | // 2019-01-15: Inputs: Added support for XInput gamepads (if ImGuiConfigFlags_NavEnableGamepad is set by user application). 24 | // 2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window. 25 | // 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor. 26 | // 2018-06-10: Inputs: Fixed handling of mouse wheel messages to support fine position messages (typically sent by track-pads). 27 | // 2018-06-08: Misc: Extracted imgui_impl_win32.cpp/.h away from the old combined DX9/DX10/DX11/DX12 examples. 28 | // 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors and ImGuiBackendFlags_HasSetMousePos flags + honor ImGuiConfigFlags_NoMouseCursorChange flag. 29 | // 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value and WM_SETCURSOR message handling). 30 | // 2018-02-06: Inputs: Added mapping for ImGuiKey_Space. 31 | // 2018-02-06: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set). 32 | // 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves. 33 | // 2018-01-20: Inputs: Added Horizontal Mouse Wheel support. 34 | // 2018-01-08: Inputs: Added mapping for ImGuiKey_Insert. 35 | // 2018-01-05: Inputs: Added WM_LBUTTONDBLCLK double-click handlers for window classes with the CS_DBLCLKS flag. 36 | // 2017-10-23: Inputs: Added WM_SYSKEYDOWN / WM_SYSKEYUP handlers so e.g. the VK_MENU key can be read. 37 | // 2017-10-23: Inputs: Using Win32 ::SetCapture/::GetCapture() to retrieve mouse positions outside the client area when dragging. 38 | // 2016-11-12: Inputs: Only call Win32 ::SetCursor(NULL) when io.MouseDrawCursor is set. 39 | 40 | // Win32 Data 41 | static HWND g_hWnd = 0; 42 | static INT64 g_Time = 0; 43 | static INT64 g_TicksPerSecond = 0; 44 | static ImGuiMouseCursor g_LastMouseCursor = ImGuiMouseCursor_COUNT; 45 | static bool g_HasGamepad = false; 46 | static bool g_WantUpdateHasGamepad = true; 47 | 48 | // Functions 49 | bool ImGui_ImplWin32_Init(void* hwnd) 50 | { 51 | if (!::QueryPerformanceFrequency((LARGE_INTEGER *)&g_TicksPerSecond)) 52 | return false; 53 | if (!::QueryPerformanceCounter((LARGE_INTEGER *)&g_Time)) 54 | return false; 55 | 56 | // Setup back-end capabilities flags 57 | g_hWnd = (HWND)hwnd; 58 | ImGuiIO& io = ImGui::GetIO(); 59 | io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional) 60 | io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used) 61 | io.BackendPlatformName = "imgui_impl_win32"; 62 | io.ImeWindowHandle = hwnd; 63 | 64 | // Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array that we will update during the application lifetime. 65 | io.KeyMap[ImGuiKey_Tab] = VK_TAB; 66 | io.KeyMap[ImGuiKey_LeftArrow] = VK_LEFT; 67 | io.KeyMap[ImGuiKey_RightArrow] = VK_RIGHT; 68 | io.KeyMap[ImGuiKey_UpArrow] = VK_UP; 69 | io.KeyMap[ImGuiKey_DownArrow] = VK_DOWN; 70 | io.KeyMap[ImGuiKey_PageUp] = VK_PRIOR; 71 | io.KeyMap[ImGuiKey_PageDown] = VK_NEXT; 72 | io.KeyMap[ImGuiKey_Home] = VK_HOME; 73 | io.KeyMap[ImGuiKey_End] = VK_END; 74 | io.KeyMap[ImGuiKey_Insert] = VK_INSERT; 75 | io.KeyMap[ImGuiKey_Delete] = VK_DELETE; 76 | io.KeyMap[ImGuiKey_Backspace] = VK_BACK; 77 | io.KeyMap[ImGuiKey_Space] = VK_SPACE; 78 | io.KeyMap[ImGuiKey_Enter] = VK_RETURN; 79 | io.KeyMap[ImGuiKey_Escape] = VK_ESCAPE; 80 | io.KeyMap[ImGuiKey_A] = 'A'; 81 | io.KeyMap[ImGuiKey_C] = 'C'; 82 | io.KeyMap[ImGuiKey_V] = 'V'; 83 | io.KeyMap[ImGuiKey_X] = 'X'; 84 | io.KeyMap[ImGuiKey_Y] = 'Y'; 85 | io.KeyMap[ImGuiKey_Z] = 'Z'; 86 | 87 | return true; 88 | } 89 | 90 | void ImGui_ImplWin32_Shutdown() 91 | { 92 | g_hWnd = (HWND)0; 93 | } 94 | 95 | static bool ImGui_ImplWin32_UpdateMouseCursor() 96 | { 97 | ImGuiIO& io = ImGui::GetIO(); 98 | if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) 99 | return false; 100 | 101 | ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor(); 102 | if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor) 103 | { 104 | // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor 105 | ::SetCursor(NULL); 106 | } 107 | else 108 | { 109 | // Show OS mouse cursor 110 | LPTSTR win32_cursor = IDC_ARROW; 111 | switch (imgui_cursor) 112 | { 113 | case ImGuiMouseCursor_Arrow: win32_cursor = IDC_ARROW; break; 114 | case ImGuiMouseCursor_TextInput: win32_cursor = IDC_IBEAM; break; 115 | case ImGuiMouseCursor_ResizeAll: win32_cursor = IDC_SIZEALL; break; 116 | case ImGuiMouseCursor_ResizeEW: win32_cursor = IDC_SIZEWE; break; 117 | case ImGuiMouseCursor_ResizeNS: win32_cursor = IDC_SIZENS; break; 118 | case ImGuiMouseCursor_ResizeNESW: win32_cursor = IDC_SIZENESW; break; 119 | case ImGuiMouseCursor_ResizeNWSE: win32_cursor = IDC_SIZENWSE; break; 120 | case ImGuiMouseCursor_Hand: win32_cursor = IDC_HAND; break; 121 | } 122 | ::SetCursor(::LoadCursor(NULL, win32_cursor)); 123 | } 124 | return true; 125 | } 126 | 127 | static void ImGui_ImplWin32_UpdateMousePos() 128 | { 129 | ImGuiIO& io = ImGui::GetIO(); 130 | 131 | // Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user) 132 | if (io.WantSetMousePos) 133 | { 134 | POINT pos = { (int)io.MousePos.x, (int)io.MousePos.y }; 135 | ::ClientToScreen(g_hWnd, &pos); 136 | ::SetCursorPos(pos.x, pos.y); 137 | } 138 | 139 | // Set mouse position 140 | io.MousePos = ImVec2(-FLT_MAX, -FLT_MAX); 141 | POINT pos; 142 | if (HWND active_window = ::GetForegroundWindow()) 143 | if (active_window == g_hWnd || ::IsChild(active_window, g_hWnd)) 144 | if (::GetCursorPos(&pos) && ::ScreenToClient(g_hWnd, &pos)) 145 | io.MousePos = ImVec2((float)pos.x, (float)pos.y); 146 | } 147 | 148 | #ifdef _MSC_VER 149 | #pragma comment(lib, "xinput") 150 | #endif 151 | 152 | // Gamepad navigation mapping 153 | static void ImGui_ImplWin32_UpdateGamepads() 154 | { 155 | ImGuiIO& io = ImGui::GetIO(); 156 | memset(io.NavInputs, 0, sizeof(io.NavInputs)); 157 | if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0) 158 | return; 159 | 160 | // Calling XInputGetState() every frame on disconnected gamepads is unfortunately too slow. 161 | // Instead we refresh gamepad availability by calling XInputGetCapabilities() _only_ after receiving WM_DEVICECHANGE. 162 | if (g_WantUpdateHasGamepad) 163 | { 164 | XINPUT_CAPABILITIES caps; 165 | g_HasGamepad = (XInputGetCapabilities(0, XINPUT_FLAG_GAMEPAD, &caps) == ERROR_SUCCESS); 166 | g_WantUpdateHasGamepad = false; 167 | } 168 | 169 | XINPUT_STATE xinput_state; 170 | io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad; 171 | if (g_HasGamepad && XInputGetState(0, &xinput_state) == ERROR_SUCCESS) 172 | { 173 | const XINPUT_GAMEPAD& gamepad = xinput_state.Gamepad; 174 | io.BackendFlags |= ImGuiBackendFlags_HasGamepad; 175 | 176 | #define MAP_BUTTON(NAV_NO, BUTTON_ENUM) { io.NavInputs[NAV_NO] = (gamepad.wButtons & BUTTON_ENUM) ? 1.0f : 0.0f; } 177 | #define MAP_ANALOG(NAV_NO, VALUE, V0, V1) { float vn = (float)(VALUE - V0) / (float)(V1 - V0); if (vn > 1.0f) vn = 1.0f; if (vn > 0.0f && io.NavInputs[NAV_NO] < vn) io.NavInputs[NAV_NO] = vn; } 178 | MAP_BUTTON(ImGuiNavInput_Activate, XINPUT_GAMEPAD_A); // Cross / A 179 | MAP_BUTTON(ImGuiNavInput_Cancel, XINPUT_GAMEPAD_B); // Circle / B 180 | MAP_BUTTON(ImGuiNavInput_Menu, XINPUT_GAMEPAD_X); // Square / X 181 | MAP_BUTTON(ImGuiNavInput_Input, XINPUT_GAMEPAD_Y); // Triangle / Y 182 | MAP_BUTTON(ImGuiNavInput_DpadLeft, XINPUT_GAMEPAD_DPAD_LEFT); // D-Pad Left 183 | MAP_BUTTON(ImGuiNavInput_DpadRight, XINPUT_GAMEPAD_DPAD_RIGHT); // D-Pad Right 184 | MAP_BUTTON(ImGuiNavInput_DpadUp, XINPUT_GAMEPAD_DPAD_UP); // D-Pad Up 185 | MAP_BUTTON(ImGuiNavInput_DpadDown, XINPUT_GAMEPAD_DPAD_DOWN); // D-Pad Down 186 | MAP_BUTTON(ImGuiNavInput_FocusPrev, XINPUT_GAMEPAD_LEFT_SHOULDER); // L1 / LB 187 | MAP_BUTTON(ImGuiNavInput_FocusNext, XINPUT_GAMEPAD_RIGHT_SHOULDER); // R1 / RB 188 | MAP_BUTTON(ImGuiNavInput_TweakSlow, XINPUT_GAMEPAD_LEFT_SHOULDER); // L1 / LB 189 | MAP_BUTTON(ImGuiNavInput_TweakFast, XINPUT_GAMEPAD_RIGHT_SHOULDER); // R1 / RB 190 | MAP_ANALOG(ImGuiNavInput_LStickLeft, gamepad.sThumbLX, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32768); 191 | MAP_ANALOG(ImGuiNavInput_LStickRight, gamepad.sThumbLX, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767); 192 | MAP_ANALOG(ImGuiNavInput_LStickUp, gamepad.sThumbLY, +XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, +32767); 193 | MAP_ANALOG(ImGuiNavInput_LStickDown, gamepad.sThumbLY, -XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE, -32767); 194 | #undef MAP_BUTTON 195 | #undef MAP_ANALOG 196 | } 197 | } 198 | 199 | void ImGui_ImplWin32_NewFrame() 200 | { 201 | ImGuiIO& io = ImGui::GetIO(); 202 | IM_ASSERT(io.Fonts->IsBuilt() && "Font atlas not built! It is generally built by the renderer back-end. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame()."); 203 | 204 | // Setup display size (every frame to accommodate for window resizing) 205 | RECT rect; 206 | ::GetClientRect(g_hWnd, &rect); 207 | io.DisplaySize = ImVec2((float)(rect.right - rect.left), (float)(rect.bottom - rect.top)); 208 | 209 | // Setup time step 210 | INT64 current_time; 211 | ::QueryPerformanceCounter((LARGE_INTEGER *)¤t_time); 212 | io.DeltaTime = (float)(current_time - g_Time) / g_TicksPerSecond; 213 | g_Time = current_time; 214 | 215 | // Read keyboard modifiers inputs 216 | io.KeyCtrl = (::GetKeyState(VK_CONTROL) & 0x8000) != 0; 217 | io.KeyShift = (::GetKeyState(VK_SHIFT) & 0x8000) != 0; 218 | io.KeyAlt = (::GetKeyState(VK_MENU) & 0x8000) != 0; 219 | io.KeySuper = false; 220 | // io.KeysDown[], io.MousePos, io.MouseDown[], io.MouseWheel: filled by the WndProc handler below. 221 | 222 | // Update OS mouse position 223 | ImGui_ImplWin32_UpdateMousePos(); 224 | 225 | // Update OS mouse cursor with the cursor requested by imgui 226 | ImGuiMouseCursor mouse_cursor = io.MouseDrawCursor ? ImGuiMouseCursor_None : ImGui::GetMouseCursor(); 227 | if (g_LastMouseCursor != mouse_cursor) 228 | { 229 | g_LastMouseCursor = mouse_cursor; 230 | ImGui_ImplWin32_UpdateMouseCursor(); 231 | } 232 | 233 | // Update game controllers (if available) 234 | ImGui_ImplWin32_UpdateGamepads(); 235 | } 236 | 237 | // Allow compilation with old Windows SDK. MinGW doesn't have default _WIN32_WINNT/WINVER versions. 238 | #ifndef WM_MOUSEHWHEEL 239 | #define WM_MOUSEHWHEEL 0x020E 240 | #endif 241 | #ifndef DBT_DEVNODES_CHANGED 242 | #define DBT_DEVNODES_CHANGED 0x0007 243 | #endif 244 | 245 | // Process Win32 mouse/keyboard inputs. 246 | // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs. 247 | // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application. 248 | // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application. 249 | // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags. 250 | // PS: In this Win32 handler, we use the capture API (GetCapture/SetCapture/ReleaseCapture) to be able to read mouse coordinations when dragging mouse outside of our window bounds. 251 | // PS: We treat DBLCLK messages as regular mouse down messages, so this code will work on windows classes that have the CS_DBLCLKS flag set. Our own example app code doesn't set this flag. 252 | IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) 253 | { 254 | if (ImGui::GetCurrentContext() == NULL) 255 | return false; 256 | 257 | ImGuiIO& io = ImGui::GetIO(); 258 | switch (msg) 259 | { 260 | case WM_LBUTTONDOWN: case WM_LBUTTONDBLCLK: 261 | case WM_RBUTTONDOWN: case WM_RBUTTONDBLCLK: 262 | case WM_MBUTTONDOWN: case WM_MBUTTONDBLCLK: 263 | case WM_XBUTTONDOWN: case WM_XBUTTONDBLCLK: 264 | { 265 | int button = 0; 266 | if (msg == WM_LBUTTONDOWN || msg == WM_LBUTTONDBLCLK) button = 0; 267 | if (msg == WM_RBUTTONDOWN || msg == WM_RBUTTONDBLCLK) button = 1; 268 | if (msg == WM_MBUTTONDOWN || msg == WM_MBUTTONDBLCLK) button = 2; 269 | if (msg == WM_XBUTTONDOWN || msg == WM_XBUTTONDBLCLK) button = (HIWORD(wParam) == XBUTTON1) ? 3 : 4; 270 | if (!ImGui::IsAnyMouseDown() && GetCapture() == nullptr) 271 | SetCapture(hwnd); 272 | io.MouseDown[button] = true; 273 | return true; 274 | } 275 | case WM_LBUTTONUP: 276 | case WM_RBUTTONUP: 277 | case WM_MBUTTONUP: 278 | case WM_XBUTTONUP: 279 | { 280 | int button = 0; 281 | if (msg == WM_LBUTTONUP) button = 0; 282 | if (msg == WM_RBUTTONUP) button = 1; 283 | if (msg == WM_MBUTTONUP) button = 2; 284 | if (msg == WM_XBUTTONUP) button = (HIWORD(wParam) == XBUTTON1) ? 3 : 4; 285 | io.MouseDown[button] = false; 286 | if (!ImGui::IsAnyMouseDown() && GetCapture() == hwnd) 287 | ReleaseCapture(); 288 | return true; 289 | } 290 | case WM_MOUSEWHEEL: 291 | io.MouseWheel += GET_WHEEL_DELTA_WPARAM(wParam) > 0 ? +1.0f : -1.0f; 292 | return true; 293 | case WM_MOUSEMOVE: 294 | io.MousePos.x = (signed short)(lParam); 295 | io.MousePos.y = (signed short)(lParam >> 16); 296 | return true; 297 | case WM_KEYDOWN: 298 | case WM_SYSKEYDOWN: 299 | if (wParam < 256) 300 | io.KeysDown[wParam] = true; 301 | return true; 302 | case WM_KEYUP: 303 | case WM_SYSKEYUP: 304 | if (wParam < 256) 305 | io.KeysDown[wParam] = false; 306 | return true; 307 | case WM_CHAR: 308 | // You can also use ToAscii()+GetKeyboardState() to retrieve characters. 309 | if (wParam > 0 && wParam < 0x10000) 310 | io.AddInputCharacter((unsigned short)wParam); 311 | return true; 312 | } 313 | return 0; 314 | } 315 | 316 | -------------------------------------------------------------------------------- /ExternalHack/IMGUI/imgui_impl_win32.h: -------------------------------------------------------------------------------- 1 | // dear imgui: Platform Binding for Windows (standard windows API for 32 and 64 bits applications) 2 | // This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..) 3 | 4 | // Implemented features: 5 | // [X] Platform: Clipboard support (for Win32 this is actually part of core imgui) 6 | // [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'. 7 | // [X] Platform: Keyboard arrays indexed using VK_* Virtual Key Codes, e.g. ImGui::IsKeyPressed(VK_SPACE). 8 | // [X] Platform: Gamepad support. Enabled with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'. 9 | 10 | #pragma once 11 | 12 | #include 13 | 14 | IMGUI_IMPL_API bool ImGui_ImplWin32_Init(void* hwnd); 15 | IMGUI_IMPL_API void ImGui_ImplWin32_Shutdown(); 16 | IMGUI_IMPL_API void ImGui_ImplWin32_NewFrame(); 17 | 18 | // Handler for Win32 messages, update mouse/keyboard data. 19 | // You may or not need this for your implementation, but it can serve as reference for handling inputs. 20 | // Intentionally commented out to avoid dragging dependencies on types. You can COPY this line into your .cpp code instead. 21 | 22 | IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); 23 | 24 | -------------------------------------------------------------------------------- /ExternalHack/IMGUI/imstb_rectpack.h: -------------------------------------------------------------------------------- 1 | // [DEAR IMGUI] 2 | // This is a slightly modified version of stb_rect_pack.h 1.00. 3 | // Those changes would need to be pushed into nothings/stb: 4 | // - Added STBRP__CDECL 5 | // Grep for [DEAR IMGUI] to find the changes. 6 | 7 | // stb_rect_pack.h - v1.00 - public domain - rectangle packing 8 | // Sean Barrett 2014 9 | // 10 | // Useful for e.g. packing rectangular textures into an atlas. 11 | // Does not do rotation. 12 | // 13 | // Not necessarily the awesomest packing method, but better than 14 | // the totally naive one in stb_truetype (which is primarily what 15 | // this is meant to replace). 16 | // 17 | // Has only had a few tests run, may have issues. 18 | // 19 | // More docs to come. 20 | // 21 | // No memory allocations; uses qsort() and assert() from stdlib. 22 | // Can override those by defining STBRP_SORT and STBRP_ASSERT. 23 | // 24 | // This library currently uses the Skyline Bottom-Left algorithm. 25 | // 26 | // Please note: better rectangle packers are welcome! Please 27 | // implement them to the same API, but with a different init 28 | // function. 29 | // 30 | // Credits 31 | // 32 | // Library 33 | // Sean Barrett 34 | // Minor features 35 | // Martins Mozeiko 36 | // github:IntellectualKitty 37 | // 38 | // Bugfixes / warning fixes 39 | // Jeremy Jaussaud 40 | // Fabian Giesen 41 | // 42 | // Version history: 43 | // 44 | // 1.00 (2019-02-25) avoid small space waste; gracefully fail too-wide rectangles 45 | // 0.99 (2019-02-07) warning fixes 46 | // 0.11 (2017-03-03) return packing success/fail result 47 | // 0.10 (2016-10-25) remove cast-away-const to avoid warnings 48 | // 0.09 (2016-08-27) fix compiler warnings 49 | // 0.08 (2015-09-13) really fix bug with empty rects (w=0 or h=0) 50 | // 0.07 (2015-09-13) fix bug with empty rects (w=0 or h=0) 51 | // 0.06 (2015-04-15) added STBRP_SORT to allow replacing qsort 52 | // 0.05: added STBRP_ASSERT to allow replacing assert 53 | // 0.04: fixed minor bug in STBRP_LARGE_RECTS support 54 | // 0.01: initial release 55 | // 56 | // LICENSE 57 | // 58 | // See end of file for license information. 59 | 60 | ////////////////////////////////////////////////////////////////////////////// 61 | // 62 | // INCLUDE SECTION 63 | // 64 | 65 | #ifndef STB_INCLUDE_STB_RECT_PACK_H 66 | #define STB_INCLUDE_STB_RECT_PACK_H 67 | 68 | #define STB_RECT_PACK_VERSION 1 69 | 70 | #ifdef STBRP_STATIC 71 | #define STBRP_DEF static 72 | #else 73 | #define STBRP_DEF extern 74 | #endif 75 | 76 | #ifdef __cplusplus 77 | extern "C" { 78 | #endif 79 | 80 | typedef struct stbrp_context stbrp_context; 81 | typedef struct stbrp_node stbrp_node; 82 | typedef struct stbrp_rect stbrp_rect; 83 | 84 | #ifdef STBRP_LARGE_RECTS 85 | typedef int stbrp_coord; 86 | #else 87 | typedef unsigned short stbrp_coord; 88 | #endif 89 | 90 | STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects); 91 | // Assign packed locations to rectangles. The rectangles are of type 92 | // 'stbrp_rect' defined below, stored in the array 'rects', and there 93 | // are 'num_rects' many of them. 94 | // 95 | // Rectangles which are successfully packed have the 'was_packed' flag 96 | // set to a non-zero value and 'x' and 'y' store the minimum location 97 | // on each axis (i.e. bottom-left in cartesian coordinates, top-left 98 | // if you imagine y increasing downwards). Rectangles which do not fit 99 | // have the 'was_packed' flag set to 0. 100 | // 101 | // You should not try to access the 'rects' array from another thread 102 | // while this function is running, as the function temporarily reorders 103 | // the array while it executes. 104 | // 105 | // To pack into another rectangle, you need to call stbrp_init_target 106 | // again. To continue packing into the same rectangle, you can call 107 | // this function again. Calling this multiple times with multiple rect 108 | // arrays will probably produce worse packing results than calling it 109 | // a single time with the full rectangle array, but the option is 110 | // available. 111 | // 112 | // The function returns 1 if all of the rectangles were successfully 113 | // packed and 0 otherwise. 114 | 115 | struct stbrp_rect 116 | { 117 | // reserved for your use: 118 | int id; 119 | 120 | // input: 121 | stbrp_coord w, h; 122 | 123 | // output: 124 | stbrp_coord x, y; 125 | int was_packed; // non-zero if valid packing 126 | 127 | }; // 16 bytes, nominally 128 | 129 | 130 | STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes); 131 | // Initialize a rectangle packer to: 132 | // pack a rectangle that is 'width' by 'height' in dimensions 133 | // using temporary storage provided by the array 'nodes', which is 'num_nodes' long 134 | // 135 | // You must call this function every time you start packing into a new target. 136 | // 137 | // There is no "shutdown" function. The 'nodes' memory must stay valid for 138 | // the following stbrp_pack_rects() call (or calls), but can be freed after 139 | // the call (or calls) finish. 140 | // 141 | // Note: to guarantee best results, either: 142 | // 1. make sure 'num_nodes' >= 'width' 143 | // or 2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1' 144 | // 145 | // If you don't do either of the above things, widths will be quantized to multiples 146 | // of small integers to guarantee the algorithm doesn't run out of temporary storage. 147 | // 148 | // If you do #2, then the non-quantized algorithm will be used, but the algorithm 149 | // may run out of temporary storage and be unable to pack some rectangles. 150 | 151 | STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem); 152 | // Optionally call this function after init but before doing any packing to 153 | // change the handling of the out-of-temp-memory scenario, described above. 154 | // If you call init again, this will be reset to the default (false). 155 | 156 | 157 | STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic); 158 | // Optionally select which packing heuristic the library should use. Different 159 | // heuristics will produce better/worse results for different data sets. 160 | // If you call init again, this will be reset to the default. 161 | 162 | enum 163 | { 164 | STBRP_HEURISTIC_Skyline_default=0, 165 | STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default, 166 | STBRP_HEURISTIC_Skyline_BF_sortHeight 167 | }; 168 | 169 | 170 | ////////////////////////////////////////////////////////////////////////////// 171 | // 172 | // the details of the following structures don't matter to you, but they must 173 | // be visible so you can handle the memory allocations for them 174 | 175 | struct stbrp_node 176 | { 177 | stbrp_coord x,y; 178 | stbrp_node *next; 179 | }; 180 | 181 | struct stbrp_context 182 | { 183 | int width; 184 | int height; 185 | int align; 186 | int init_mode; 187 | int heuristic; 188 | int num_nodes; 189 | stbrp_node *active_head; 190 | stbrp_node *free_head; 191 | stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2' 192 | }; 193 | 194 | #ifdef __cplusplus 195 | } 196 | #endif 197 | 198 | #endif 199 | 200 | ////////////////////////////////////////////////////////////////////////////// 201 | // 202 | // IMPLEMENTATION SECTION 203 | // 204 | 205 | #ifdef STB_RECT_PACK_IMPLEMENTATION 206 | #ifndef STBRP_SORT 207 | #include 208 | #define STBRP_SORT qsort 209 | #endif 210 | 211 | #ifndef STBRP_ASSERT 212 | #include 213 | #define STBRP_ASSERT assert 214 | #endif 215 | 216 | // [DEAR IMGUI] Added STBRP__CDECL 217 | #ifdef _MSC_VER 218 | #define STBRP__NOTUSED(v) (void)(v) 219 | #define STBRP__CDECL __cdecl 220 | #else 221 | #define STBRP__NOTUSED(v) (void)sizeof(v) 222 | #define STBRP__CDECL 223 | #endif 224 | 225 | enum 226 | { 227 | STBRP__INIT_skyline = 1 228 | }; 229 | 230 | STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic) 231 | { 232 | switch (context->init_mode) { 233 | case STBRP__INIT_skyline: 234 | STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight); 235 | context->heuristic = heuristic; 236 | break; 237 | default: 238 | STBRP_ASSERT(0); 239 | } 240 | } 241 | 242 | STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem) 243 | { 244 | if (allow_out_of_mem) 245 | // if it's ok to run out of memory, then don't bother aligning them; 246 | // this gives better packing, but may fail due to OOM (even though 247 | // the rectangles easily fit). @TODO a smarter approach would be to only 248 | // quantize once we've hit OOM, then we could get rid of this parameter. 249 | context->align = 1; 250 | else { 251 | // if it's not ok to run out of memory, then quantize the widths 252 | // so that num_nodes is always enough nodes. 253 | // 254 | // I.e. num_nodes * align >= width 255 | // align >= width / num_nodes 256 | // align = ceil(width/num_nodes) 257 | 258 | context->align = (context->width + context->num_nodes-1) / context->num_nodes; 259 | } 260 | } 261 | 262 | STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes) 263 | { 264 | int i; 265 | #ifndef STBRP_LARGE_RECTS 266 | STBRP_ASSERT(width <= 0xffff && height <= 0xffff); 267 | #endif 268 | 269 | for (i=0; i < num_nodes-1; ++i) 270 | nodes[i].next = &nodes[i+1]; 271 | nodes[i].next = NULL; 272 | context->init_mode = STBRP__INIT_skyline; 273 | context->heuristic = STBRP_HEURISTIC_Skyline_default; 274 | context->free_head = &nodes[0]; 275 | context->active_head = &context->extra[0]; 276 | context->width = width; 277 | context->height = height; 278 | context->num_nodes = num_nodes; 279 | stbrp_setup_allow_out_of_mem(context, 0); 280 | 281 | // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly) 282 | context->extra[0].x = 0; 283 | context->extra[0].y = 0; 284 | context->extra[0].next = &context->extra[1]; 285 | context->extra[1].x = (stbrp_coord) width; 286 | #ifdef STBRP_LARGE_RECTS 287 | context->extra[1].y = (1<<30); 288 | #else 289 | context->extra[1].y = 65535; 290 | #endif 291 | context->extra[1].next = NULL; 292 | } 293 | 294 | // find minimum y position if it starts at x1 295 | static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste) 296 | { 297 | stbrp_node *node = first; 298 | int x1 = x0 + width; 299 | int min_y, visited_width, waste_area; 300 | 301 | STBRP__NOTUSED(c); 302 | 303 | STBRP_ASSERT(first->x <= x0); 304 | 305 | #if 0 306 | // skip in case we're past the node 307 | while (node->next->x <= x0) 308 | ++node; 309 | #else 310 | STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency 311 | #endif 312 | 313 | STBRP_ASSERT(node->x <= x0); 314 | 315 | min_y = 0; 316 | waste_area = 0; 317 | visited_width = 0; 318 | while (node->x < x1) { 319 | if (node->y > min_y) { 320 | // raise min_y higher. 321 | // we've accounted for all waste up to min_y, 322 | // but we'll now add more waste for everything we've visted 323 | waste_area += visited_width * (node->y - min_y); 324 | min_y = node->y; 325 | // the first time through, visited_width might be reduced 326 | if (node->x < x0) 327 | visited_width += node->next->x - x0; 328 | else 329 | visited_width += node->next->x - node->x; 330 | } else { 331 | // add waste area 332 | int under_width = node->next->x - node->x; 333 | if (under_width + visited_width > width) 334 | under_width = width - visited_width; 335 | waste_area += under_width * (min_y - node->y); 336 | visited_width += under_width; 337 | } 338 | node = node->next; 339 | } 340 | 341 | *pwaste = waste_area; 342 | return min_y; 343 | } 344 | 345 | typedef struct 346 | { 347 | int x,y; 348 | stbrp_node **prev_link; 349 | } stbrp__findresult; 350 | 351 | static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height) 352 | { 353 | int best_waste = (1<<30), best_x, best_y = (1 << 30); 354 | stbrp__findresult fr; 355 | stbrp_node **prev, *node, *tail, **best = NULL; 356 | 357 | // align to multiple of c->align 358 | width = (width + c->align - 1); 359 | width -= width % c->align; 360 | STBRP_ASSERT(width % c->align == 0); 361 | 362 | // if it can't possibly fit, bail immediately 363 | if (width > c->width || height > c->height) { 364 | fr.prev_link = NULL; 365 | fr.x = fr.y = 0; 366 | return fr; 367 | } 368 | 369 | node = c->active_head; 370 | prev = &c->active_head; 371 | while (node->x + width <= c->width) { 372 | int y,waste; 373 | y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste); 374 | if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL 375 | // bottom left 376 | if (y < best_y) { 377 | best_y = y; 378 | best = prev; 379 | } 380 | } else { 381 | // best-fit 382 | if (y + height <= c->height) { 383 | // can only use it if it first vertically 384 | if (y < best_y || (y == best_y && waste < best_waste)) { 385 | best_y = y; 386 | best_waste = waste; 387 | best = prev; 388 | } 389 | } 390 | } 391 | prev = &node->next; 392 | node = node->next; 393 | } 394 | 395 | best_x = (best == NULL) ? 0 : (*best)->x; 396 | 397 | // if doing best-fit (BF), we also have to try aligning right edge to each node position 398 | // 399 | // e.g, if fitting 400 | // 401 | // ____________________ 402 | // |____________________| 403 | // 404 | // into 405 | // 406 | // | | 407 | // | ____________| 408 | // |____________| 409 | // 410 | // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned 411 | // 412 | // This makes BF take about 2x the time 413 | 414 | if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) { 415 | tail = c->active_head; 416 | node = c->active_head; 417 | prev = &c->active_head; 418 | // find first node that's admissible 419 | while (tail->x < width) 420 | tail = tail->next; 421 | while (tail) { 422 | int xpos = tail->x - width; 423 | int y,waste; 424 | STBRP_ASSERT(xpos >= 0); 425 | // find the left position that matches this 426 | while (node->next->x <= xpos) { 427 | prev = &node->next; 428 | node = node->next; 429 | } 430 | STBRP_ASSERT(node->next->x > xpos && node->x <= xpos); 431 | y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste); 432 | if (y + height <= c->height) { 433 | if (y <= best_y) { 434 | if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) { 435 | best_x = xpos; 436 | STBRP_ASSERT(y <= best_y); 437 | best_y = y; 438 | best_waste = waste; 439 | best = prev; 440 | } 441 | } 442 | } 443 | tail = tail->next; 444 | } 445 | } 446 | 447 | fr.prev_link = best; 448 | fr.x = best_x; 449 | fr.y = best_y; 450 | return fr; 451 | } 452 | 453 | static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height) 454 | { 455 | // find best position according to heuristic 456 | stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height); 457 | stbrp_node *node, *cur; 458 | 459 | // bail if: 460 | // 1. it failed 461 | // 2. the best node doesn't fit (we don't always check this) 462 | // 3. we're out of memory 463 | if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) { 464 | res.prev_link = NULL; 465 | return res; 466 | } 467 | 468 | // on success, create new node 469 | node = context->free_head; 470 | node->x = (stbrp_coord) res.x; 471 | node->y = (stbrp_coord) (res.y + height); 472 | 473 | context->free_head = node->next; 474 | 475 | // insert the new node into the right starting point, and 476 | // let 'cur' point to the remaining nodes needing to be 477 | // stiched back in 478 | 479 | cur = *res.prev_link; 480 | if (cur->x < res.x) { 481 | // preserve the existing one, so start testing with the next one 482 | stbrp_node *next = cur->next; 483 | cur->next = node; 484 | cur = next; 485 | } else { 486 | *res.prev_link = node; 487 | } 488 | 489 | // from here, traverse cur and free the nodes, until we get to one 490 | // that shouldn't be freed 491 | while (cur->next && cur->next->x <= res.x + width) { 492 | stbrp_node *next = cur->next; 493 | // move the current node to the free list 494 | cur->next = context->free_head; 495 | context->free_head = cur; 496 | cur = next; 497 | } 498 | 499 | // stitch the list back in 500 | node->next = cur; 501 | 502 | if (cur->x < res.x + width) 503 | cur->x = (stbrp_coord) (res.x + width); 504 | 505 | #ifdef _DEBUG 506 | cur = context->active_head; 507 | while (cur->x < context->width) { 508 | STBRP_ASSERT(cur->x < cur->next->x); 509 | cur = cur->next; 510 | } 511 | STBRP_ASSERT(cur->next == NULL); 512 | 513 | { 514 | int count=0; 515 | cur = context->active_head; 516 | while (cur) { 517 | cur = cur->next; 518 | ++count; 519 | } 520 | cur = context->free_head; 521 | while (cur) { 522 | cur = cur->next; 523 | ++count; 524 | } 525 | STBRP_ASSERT(count == context->num_nodes+2); 526 | } 527 | #endif 528 | 529 | return res; 530 | } 531 | 532 | // [DEAR IMGUI] Added STBRP__CDECL 533 | static int STBRP__CDECL rect_height_compare(const void *a, const void *b) 534 | { 535 | const stbrp_rect *p = (const stbrp_rect *) a; 536 | const stbrp_rect *q = (const stbrp_rect *) b; 537 | if (p->h > q->h) 538 | return -1; 539 | if (p->h < q->h) 540 | return 1; 541 | return (p->w > q->w) ? -1 : (p->w < q->w); 542 | } 543 | 544 | // [DEAR IMGUI] Added STBRP__CDECL 545 | static int STBRP__CDECL rect_original_order(const void *a, const void *b) 546 | { 547 | const stbrp_rect *p = (const stbrp_rect *) a; 548 | const stbrp_rect *q = (const stbrp_rect *) b; 549 | return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed); 550 | } 551 | 552 | #ifdef STBRP_LARGE_RECTS 553 | #define STBRP__MAXVAL 0xffffffff 554 | #else 555 | #define STBRP__MAXVAL 0xffff 556 | #endif 557 | 558 | STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects) 559 | { 560 | int i, all_rects_packed = 1; 561 | 562 | // we use the 'was_packed' field internally to allow sorting/unsorting 563 | for (i=0; i < num_rects; ++i) { 564 | rects[i].was_packed = i; 565 | } 566 | 567 | // sort according to heuristic 568 | STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare); 569 | 570 | for (i=0; i < num_rects; ++i) { 571 | if (rects[i].w == 0 || rects[i].h == 0) { 572 | rects[i].x = rects[i].y = 0; // empty rect needs no space 573 | } else { 574 | stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h); 575 | if (fr.prev_link) { 576 | rects[i].x = (stbrp_coord) fr.x; 577 | rects[i].y = (stbrp_coord) fr.y; 578 | } else { 579 | rects[i].x = rects[i].y = STBRP__MAXVAL; 580 | } 581 | } 582 | } 583 | 584 | // unsort 585 | STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order); 586 | 587 | // set was_packed flags and all_rects_packed status 588 | for (i=0; i < num_rects; ++i) { 589 | rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL); 590 | if (!rects[i].was_packed) 591 | all_rects_packed = 0; 592 | } 593 | 594 | // return the all_rects_packed status 595 | return all_rects_packed; 596 | } 597 | #endif 598 | 599 | /* 600 | ------------------------------------------------------------------------------ 601 | This software is available under 2 licenses -- choose whichever you prefer. 602 | ------------------------------------------------------------------------------ 603 | ALTERNATIVE A - MIT License 604 | Copyright (c) 2017 Sean Barrett 605 | Permission is hereby granted, free of charge, to any person obtaining a copy of 606 | this software and associated documentation files (the "Software"), to deal in 607 | the Software without restriction, including without limitation the rights to 608 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 609 | of the Software, and to permit persons to whom the Software is furnished to do 610 | so, subject to the following conditions: 611 | The above copyright notice and this permission notice shall be included in all 612 | copies or substantial portions of the Software. 613 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 614 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 615 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 616 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 617 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 618 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 619 | SOFTWARE. 620 | ------------------------------------------------------------------------------ 621 | ALTERNATIVE B - Public Domain (www.unlicense.org) 622 | This is free and unencumbered software released into the public domain. 623 | Anyone is free to copy, modify, publish, use, compile, sell, or distribute this 624 | software, either in source code form or as a compiled binary, for any purpose, 625 | commercial or non-commercial, and by any means. 626 | In jurisdictions that recognize copyright laws, the author or authors of this 627 | software dedicate any and all copyright interest in the software to the public 628 | domain. We make this dedication for the benefit of the public at large and to 629 | the detriment of our heirs and successors. We intend this dedication to be an 630 | overt act of relinquishment in perpetuity of all present and future rights to 631 | this software under copyright law. 632 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 633 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 634 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 635 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 636 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 637 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 638 | ------------------------------------------------------------------------------ 639 | */ 640 | -------------------------------------------------------------------------------- /ExternalHack/Release/BRLNSB.TTF: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/BRLNSB.TTF -------------------------------------------------------------------------------- /ExternalHack/Release/BRLNSDB.TTF: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/BRLNSDB.TTF -------------------------------------------------------------------------------- /ExternalHack/Release/BRLNSR.TTF: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/BRLNSR.TTF -------------------------------------------------------------------------------- /ExternalHack/Release/ExternalHack 28,06 UD.rar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/ExternalHack 28,06 UD.rar -------------------------------------------------------------------------------- /ExternalHack/Release/ExternalHack.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/ExternalHack.exe -------------------------------------------------------------------------------- /ExternalHack/Release/Untitled1.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/Untitled1.ttf -------------------------------------------------------------------------------- /ExternalHack/Release/undefeated.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rrpvm/csgo-external-cheat/28256287f51e8ae866c6587f071855cb304cb2a1/ExternalHack/Release/undefeated.ttf -------------------------------------------------------------------------------- /ExternalHack/menu.cpp: -------------------------------------------------------------------------------- 1 | #include "menu.h" 2 | #include 3 | #include "fakelag.h" 4 | #include "SkinChanger.h" 5 | LRESULT WINAPI WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) 6 | { 7 | if (menu::get().showMenu && ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam)) 8 | { 9 | return true; 10 | } 11 | return CallWindowProc(menu::get().wndproc_orig, hwnd, msg, wParam, lParam); 12 | } 13 | void menu::init() 14 | { 15 | if (!isInit) 16 | { 17 | wndproc_orig = (WNDPROC)SetWindowLongPtr(FindWindowA(NULL, "ExternalByRoman"), GWLP_WNDPROC, (LONG_PTR)WndProc); 18 | ImGui::CreateContext(); 19 | ImGuiIO& io = ImGui::GetIO(); 20 | ImGui_ImplWin32_Init(FindWindowA(NULL, "ExternalByRoman")); 21 | ImGui_ImplDX9_Init(GlobalVars::get().pDevice); 22 | fTabs = io.Fonts->AddFontFromFileTTF("Untitled1.ttf", 62.0f); 23 | weaponTabs = io.Fonts->AddFontFromFileTTF("undefeated.ttf", 12.0f); 24 | defFont = io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\Verdana.TTF", 16.0f); 25 | isInit = true; 26 | } 27 | } 28 | 29 | void menu::drawMainMenu() 30 | { 31 | if (GetAsyncKeyState(VK_INSERT) & 1) 32 | { 33 | showMenu = !showMenu; 34 | if (showMenu) 35 | { 36 | SetWindowLongPtr(GlobalVars::get().overlayHWND, GWL_EXSTYLE, WS_EX_LAYERED); 37 | } 38 | else SetWindowLongPtr(GlobalVars::get().overlayHWND, GWL_EXSTYLE, WS_EX_LAYERED | WS_EX_TRANSPARENT); 39 | } 40 | 41 | init(); 42 | ImGui_ImplDX9_NewFrame(); 43 | ImGui_ImplWin32_NewFrame(); 44 | ImGui::NewFrame(); 45 | if (showMenu) 46 | { 47 | if (isInit) 48 | { 49 | setStyles();// 50 | 51 | ImGui::SetNextWindowSize(ImVec2(sizeX, sizeY), ImGuiCond_Always); 52 | ImGuiStyle& style = ImGui::GetStyle(); 53 | ImGui::PushFont(defFont); 54 | ImGui::Begin("Menu", &showMenu, ImGuiCond_Always | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar); 55 | { 56 | ImGui::BeginChild("OVER_MENU", ImVec2(640, 33), true, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize); 57 | { 58 | ImGui::SameLine(640 / 2 - ImGui::CalcTextSize("ExternalHack status:(UNDETECT) V1.02 pre-release").x / 2); 59 | ImGui::SetCursorPosY(10); 60 | ImGui::Text("ExternalHack status:(UNDETECT) V1.02 pre-release"); 61 | } 62 | ImGui::EndChild(); 63 | ImGui::BeginChild("menu-tabs", ImVec2(165, sizeY), true, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize); 64 | { 65 | ImGui::NewLine(); 66 | ImGui::PushFont(fTabs); 67 | currTab == 2 ? style.FrameBorderSize = 1.f : style.FrameBorderSize = 0.f; 68 | currTab == 2 ? style.Colors[ImGuiCol_Button] = ImVec4(.2f, .2f, .2f, 1.f) : style.Colors[ImGuiCol_Button] = ImVec4(.1f, .1f, .1f, 1.f); 69 | if (ImGui::Button("a", ImVec2(165, sizeY / 5))) 70 | { 71 | currTab = 2; 72 | } 73 | currTab == 1 ? style.FrameBorderSize = 1.f : style.FrameBorderSize = 0.f; 74 | currTab == 1 ? style.Colors[ImGuiCol_Button] = ImVec4(.2f, .2f, .2f, 1.f) : style.Colors[ImGuiCol_Button] = ImVec4(.1f, .1f, .1f, 1.f); 75 | if (ImGui::Button("b", ImVec2(165, sizeY / 5))) 76 | { 77 | currTab = 1; 78 | } 79 | currTab == 3 ? style.FrameBorderSize = 1.f : style.FrameBorderSize = 0.f; 80 | currTab == 3 ? style.Colors[ImGuiCol_Button] = ImVec4(.2f, .2f, .2f, 1.f) : style.Colors[ImGuiCol_Button] = ImVec4(.1f, .1f, .1f, 1.f); 81 | if (ImGui::Button("f", ImVec2(165, sizeY / 5))) 82 | { 83 | currTab = 3; 84 | } 85 | currTab == 4 ? style.FrameBorderSize = 1.f : style.FrameBorderSize = 0.f; 86 | currTab == 4 ? style.Colors[ImGuiCol_Button] = ImVec4(.2f, .2f, .2f, 1.f) : style.Colors[ImGuiCol_Button] = ImVec4(.1f, .1f, .1f, 1.f); 87 | if (ImGui::Button("d", ImVec2(165, sizeY / 5))) 88 | { 89 | currTab = 4; 90 | } 91 | style.FrameBorderSize = 1.f; 92 | ImGui::PopFont(); 93 | } 94 | ImGui::EndChild(); 95 | ImGui::SameLine(); 96 | ImGui::BeginChild("sub-tabs", ImVec2(sizeX - 165, 480), false, ImGuiWindowFlags_NoScrollbar); 97 | { 98 | switch (currTab) 99 | { 100 | case 1: { 101 | drawVisualSubTab(); 102 | break; 103 | } 104 | case 2: { 105 | drawAimbotTab(); 106 | break; 107 | } 108 | case 3: { 109 | drawMiscTab(); 110 | break; 111 | } 112 | case 4: { 113 | drawCFGTab(); 114 | break; 115 | } 116 | 117 | } 118 | } 119 | } 120 | } 121 | 122 | 123 | } 124 | ImGui::EndChild(); 125 | } 126 | 127 | void menu::endMenuScene() 128 | { 129 | ImGui::End(); 130 | ImGui::EndFrame(); 131 | ImGui::Render(); 132 | ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData()); 133 | } 134 | 135 | void menu::setStyles() 136 | { 137 | ImGuiStyle& style = ImGui::GetStyle(); 138 | style.Alpha = 255.f; 139 | style.ChildBorderSize = 0.8f; 140 | style.DisplaySafeAreaPadding = ImVec2(0, 0); 141 | style.DisplayWindowPadding = ImVec2(0, 0); 142 | style.FramePadding = ImVec2(8, 2); 143 | style.IndentSpacing = 10.f; 144 | style.ItemInnerSpacing = ImVec2(12, 0); 145 | style.ItemSpacing = ImVec2(10,0); 146 | style.WindowPadding = ImVec2(0, 0); 147 | style.ButtonTextAlign = ImVec2(0.5f, 0.5f); 148 | style.FrameBorderSize = 0.f; 149 | style.FrameRounding =2.0f; 150 | style.WindowRounding = 5.0f; 151 | 152 | style.Colors[ImGuiCol_Button] = ImVec4(.1f, .1f, .1f,1.f); 153 | style.Colors[ImGuiCol_ButtonActive] = ImVec4(.1f, .1f, .1f,1.f); 154 | style.Colors[ImGuiCol_ButtonHovered] = ImVec4(.2f, .2f, .2f,1.f); 155 | style.Colors[ImGuiCol_WindowBg] = ImVec4(Config::get().menuFrameColor[0], Config::get().menuFrameColor[1], Config::get().menuFrameColor[2], Config::get().menuFrameColor[3]); 156 | style.Colors[ImGuiCol_ChildBg] = ImVec4(Config::get().menuChildColor[0], Config::get().menuChildColor[1], Config::get().menuChildColor[2], Config::get().menuChildColor[3]); 157 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxesColor[0], Config::get().menuCheckboxesColor[1], Config::get().menuCheckboxesColor[2], Config::get().menuCheckboxesColor[3]); 158 | style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(Config::get().menuCheckedCBoxes[0] + .1f, Config::get().menuCheckedCBoxes[1] + .1f, Config::get().menuCheckedCBoxes[2] + .1f, Config::get().menuCheckedCBoxes[3]); 159 | style.Colors[ImGuiCol_FrameBgActive] = ImVec4(Config::get().menuCheckedCBoxes[0] + .2f, Config::get().menuCheckedCBoxes[1] + .2f, Config::get().menuCheckedCBoxes[2] + .2f, Config::get().menuCheckedCBoxes[3]); 160 | style.Colors[ImGuiCol_CheckMark] = ImVec4(Config::get().menuCheckedCBoxes[0], Config::get().menuCheckedCBoxes[1], Config::get().menuCheckedCBoxes[2], Config::get().menuCheckedCBoxes[3]); 161 | 162 | 163 | 164 | style.Colors[ImGuiCol_Tab] = ImVec4(.2f, .2f, .2f, 1.f); 165 | style.Colors[ImGuiCol_PopupBg] = ImVec4(.2f, .2f, .2f, 1.f); 166 | style.Colors[ImGuiCol_HeaderHovered] = ImVec4(.5f, .2f, .2f, 1.f); 167 | style.Colors[ImGuiCol_Header] = ImVec4(.5f, .2f, .2f, 1.f); 168 | style.FrameBorderSize = .1f; 169 | } 170 | 171 | void menu::drawAimbotTab() 172 | { 173 | ImGuiStyle& style = ImGui::GetStyle(); 174 | style.FrameBorderSize = 0.f; 175 | style.PopupBorderSize = 0.f; 176 | style.TabBorderSize = 0.f; 177 | style.WindowPadding = ImVec2(9, 2); 178 | style.ItemInnerSpacing = ImVec2(9, 15); 179 | style.ItemSpacing = ImVec2(5, 9); 180 | 181 | ImGui::BeginChild("Functions", ImVec2((sizeX - 165) / 2, 480), true); 182 | ImGui::SetCursorPosY(10); 183 | ImGui::SetCursorPosX((sizeX - 165) / 4 - ImGui::CalcTextSize("Functions").x); 184 | ImGui::Text("Functions"); 185 | ImGui::SetCursorPosY(50); 186 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxWarningColor[0], Config::get().menuCheckboxWarningColor[1], Config::get().menuCheckboxWarningColor[2], Config::get().menuCheckboxWarningColor[3]); 187 | ImGui::Checkbox("Angle Aimbot", &Config::get().WriteAimBot); 188 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxesColor[0], Config::get().menuCheckboxesColor[1], Config::get().menuCheckboxesColor[2], Config::get().menuCheckboxesColor[3]); 189 | ImGui::Checkbox("Cursor Aimbot", &Config::get().SafeAimBot); 190 | ImGui::Checkbox("dormant aim", &Config::get().aimDormantCheck); 191 | ImGui::Checkbox("RCS", &Config::get().RCS); 192 | ImGui::SetNextItemWidth((sizeX - 165) / 2 - 70); 193 | ImGui::SetCursorPosX(9); ImGui::SliderInt("FOV", &Config::get().FOV, 1, 120, "%d"); 194 | ImGui::SetCursorPosX(9); 195 | ImGui::SetNextItemWidth((sizeX - 165) / 2 - 70); 196 | ImGui::SliderInt("SMOOTH", &Config::get().Smooth, 1, 100, "%d"); 197 | ImGui::EndChild(); 198 | ImGui::SameLine(); 199 | ImGui::BeginChild("Other", ImVec2((sizeX - 165) / 2, 480), true); 200 | ImGui::SetNextItemWidth(120); 201 | ImGui::SetCursorPosY(50);; 202 | ImGui::Combo("aim bone", &Config::get().currBone, Config::get().aim_preference, sizeof(Config::get().aim_preference) / sizeof(Config::get().aim_preference[0]), sizeof(Config::get().aim_preference) / sizeof(Config::get().aim_preference[0])); 203 | ImGui::Button("Aim key(coming soon)"); 204 | if (ImGui::Checkbox("FakeLag", &Config::get().fake_lag)) { 205 | static bool once = true; 206 | if (once) { 207 | if (!Config::get().fake_lag) { fakelag::get().shutdown(); once = false; } 208 | } 209 | if (Config::get().fake_lag) 210 | { 211 | once = true; 212 | } 213 | } 214 | ImGui::SliderInt("factor", &Config::get().factor, 1, 14, "%d"); 215 | ImGui::Checkbox("indicate chocked", &Config::get().fakelag_indicator); 216 | ImGui::EndChild(); 217 | style.WindowPadding = ImVec2(0, 0); 218 | style.ItemInnerSpacing = ImVec2(1, 1); 219 | style.ItemSpacing = ImVec2(1, 1); 220 | } 221 | 222 | void menu::drawVisualSubTab() 223 | { 224 | ImGuiStyle& style = ImGui::GetStyle(); 225 | style.FrameBorderSize = 0.f; 226 | style.PopupBorderSize = 0.f; 227 | style.TabBorderSize = 0.f; 228 | style.WindowPadding = ImVec2(9, 0); 229 | ImGui::BeginChild("checkboxes", ImVec2((sizeX - 165)/2 - 50, 480),true); 230 | ImGui::SameLine(); 231 | ImGui::SetCursorPosY(20); 232 | ImGui::Text("Functions"); 233 | ImGui::NewLine(); 234 | style.ItemInnerSpacing = ImVec2(9, 15); 235 | style.ItemSpacing = ImVec2(5, 5); 236 | 237 | ImGui::Checkbox("BoxEsp", &Config::get().BoxEsp); 238 | ImGui::Checkbox("Line Esp", &Config::get().LineEsp); 239 | ImGui::Checkbox("Hp Esp", &Config::get().HpEsp); 240 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxWarningColor[0], Config::get().menuCheckboxWarningColor[1], Config::get().menuCheckboxWarningColor[2], Config::get().menuCheckboxWarningColor[3]); 241 | ImGui::Checkbox("Glow", &Config::get().Glow); 242 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxesColor[0], Config::get().menuCheckboxesColor[1], Config::get().menuCheckboxesColor[2], Config::get().menuCheckboxesColor[3]); 243 | ImGui::Checkbox("Team Esp", &Config::get().TeamEsp); 244 | ImGui::Checkbox("only visible", &Config::get().isVisible); 245 | ImGui::Checkbox("on visible", &Config::get().onVisible); 246 | ImGui::Checkbox("drawAimTarget", &Config::get().RenderbestAimTarget); 247 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxWarningColor[0], Config::get().menuCheckboxWarningColor[1], Config::get().menuCheckboxWarningColor[2], Config::get().menuCheckboxWarningColor[3]); 248 | ImGui::Checkbox("fake chams", &Config::get().chams); 249 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxesColor[0], Config::get().menuCheckboxesColor[1], Config::get().menuCheckboxesColor[2], Config::get().menuCheckboxesColor[3]); 250 | ImGui::Checkbox("show head pos", &Config::get().showHeadPos); 251 | ImGui::Checkbox("draw FOV", &Config::get().drawFOV); 252 | ImGui::EndChild(); 253 | ImGui::SameLine(); 254 | ImGui::BeginChild("other", ImVec2((sizeX - 165) / 2 + 50, 480), true); 255 | ImGui::SetCursorPos(ImVec2(ImGui::CalcItemWidth()/1.6,20)); 256 | ImGui::Text("other"); 257 | ImGui::NewLine(); 258 | ImGui::ColorPicker4("color", Config::get().ColorBox, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 259 | ImGui::ColorPicker4("glow color", Config::get().ColorGlow, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 260 | ImGui::ColorPicker4("Box color on visible", Config::get().onVisibleColorBox, ImGuiColorEditFlags_NoInputs); 261 | ImGui::ColorPicker4("Fov Indicate color", Config::get().fovColor, ImGuiColorEditFlags_NoInputs); 262 | ImGui::SetNextItemWidth(120); 263 | ImGui::Combo("box type", &Config::get().currTypeOfBox, Config::get().boxType, sizeof(Config::get().boxType) / sizeof(Config::get().boxType[0]), sizeof(Config::get().boxType) / sizeof(Config::get().boxType[0])); 264 | ImGui::SetNextItemWidth(120); 265 | ImGui::Combo("hp pos", &Config::get().hpType,Config::get().hptype, sizeof(Config::get().hptype) / sizeof(Config::get().hptype[0]),sizeof(Config::get().hptype) / sizeof(Config::get().hptype[0])); 266 | ImGui::SetNextItemWidth(120); 267 | ImGui::Combo("Glow Type", &Config::get().currGlowType, Config::get().glowType, sizeof(Config::get().glowType) / sizeof(Config::get().glowType[0]), sizeof(Config::get().glowType) / sizeof(Config::get().glowType[0])); 268 | ImGui::Checkbox("only outline FOV", &Config::get().FOV_Outline); 269 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxWarningColor[0], Config::get().menuCheckboxWarningColor[1], Config::get().menuCheckboxWarningColor[2], Config::get().menuCheckboxWarningColor[3]); 270 | ImGui::Checkbox("Indicate player on FOV", &Config::get().FOV_Indicate); 271 | style.Colors[ImGuiCol_FrameBg] = ImVec4(.2f, .2f, .2f, 1.f); 272 | ImGui::Checkbox("EnemyWeapon", &Config::get().enemyWeapon); 273 | ImGui::Checkbox("recoil crz", &Config::get().recoilCrz); 274 | ImGui::SliderInt("glow alpha", &Config::get().glowThikness, 1, 10, "%d"); 275 | ImGui::Text("coming soon (update v2.0)"); 276 | ImGui::EndChild(); 277 | style.WindowPadding = ImVec2(0, 0); 278 | style.ItemInnerSpacing = ImVec2(1, 1); 279 | style.ItemSpacing = ImVec2(1, 1); 280 | 281 | } 282 | 283 | void menu::drawMiscTab() 284 | { 285 | ImGuiStyle& style = ImGui::GetStyle(); 286 | style.FrameBorderSize = 0.f; 287 | style.PopupBorderSize = 0.f; 288 | style.TabBorderSize = 0.f; 289 | style.WindowPadding = ImVec2(9, 2); 290 | style.ItemInnerSpacing = ImVec2(9, 15); 291 | style.ItemSpacing = ImVec2(5, 9); 292 | 293 | ImGui::BeginChild("Functions", ImVec2((sizeX - 165) / 2, 480), true); 294 | ImGui::SetCursorPosY(10); 295 | ImGui::SetCursorPosX((sizeX - 165) / 4 - ImGui::CalcTextSize("Functions").x); 296 | ImGui::Text("Functions"); 297 | ImGui::SetCursorPosY(50); 298 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxWarningColor[0], Config::get().menuCheckboxWarningColor[1], Config::get().menuCheckboxWarningColor[2], Config::get().menuCheckboxWarningColor[3]); 299 | ImGui::Checkbox("Triggerbot", &Config::get().Trigger); 300 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxesColor[0], Config::get().menuCheckboxesColor[1], Config::get().menuCheckboxesColor[2], Config::get().menuCheckboxesColor[3]); 301 | ImGui::Checkbox("Triggerbot(safe)", &Config::get().safeTrigger); 302 | ImGui::Checkbox("Bunnyhop", &Config::get().BHOP); 303 | ImGui::SliderInt("delay btw shots", &Config::get().delayBetweenShots, 1, 1000, "%d"); 304 | ImGui::Text("coming soon (update v2.0)"); 305 | ImGui::EndChild(); 306 | 307 | style.WindowPadding = ImVec2(0, 0); 308 | style.ItemInnerSpacing = ImVec2(1, 1); 309 | style.ItemSpacing = ImVec2(1, 1); 310 | } 311 | 312 | void menu::drawCFGTab() 313 | { 314 | ImGuiStyle& style = ImGui::GetStyle(); 315 | style.FrameBorderSize = 0.f; 316 | style.PopupBorderSize = 0.f; 317 | style.TabBorderSize = 0.f; 318 | style.WindowPadding = ImVec2(9, 2); 319 | style.ItemInnerSpacing = ImVec2(9, 15); 320 | style.ItemSpacing = ImVec2(5, 9); 321 | ImGui::BeginChild("Functions", ImVec2((sizeX - 165) / 2, 480), true); 322 | if (ImGui::Button("save")) 323 | { 324 | Config::get().SafeCfg(); 325 | } 326 | if (ImGui::Button("Load")) 327 | { 328 | Config::get().LoadCfg(); 329 | } 330 | if (ImGui::Button("reset")) 331 | { 332 | Config::get().ResetCFG(); 333 | } 334 | ImGui::EndChild(); 335 | ImGui::SameLine(); 336 | ImGui::BeginChild("SkinChanger", ImVec2((sizeX - 165) / 2, 480), true); 337 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxWarningColor[0], Config::get().menuCheckboxWarningColor[1], Config::get().menuCheckboxWarningColor[2], Config::get().menuCheckboxWarningColor[3]); 338 | ImGui::Checkbox("SkinChanger", &Config::get().skingChanger); 339 | style.Colors[ImGuiCol_FrameBg] = ImVec4(Config::get().menuCheckboxesColor[0], Config::get().menuCheckboxesColor[1], Config::get().menuCheckboxesColor[2], Config::get().menuCheckboxesColor[3]); 340 | if (ImGui::Button("update")) 341 | { 342 | Config::get().cfgWeapons[Config::get().currComboWeaponSkin].skinId = SkinChanger::get().getIdOfSkinByComboList(Config::get().cfgWeapons[Config::get().currComboWeaponSkin].currComboSelect); 343 | 344 | uintptr_t clientState = memory::get().read(GlobalVars::get().engine + GlobalVars::get().ofs.dwClientState); 345 | memory::get().write(clientState + 0x174, -1); 346 | memory::get().write(clientState + 0x174, -1); 347 | memory::get().write(clientState + 0x174, -1); 348 | } 349 | static bool once = true; 350 | if (once) 351 | { 352 | for (int i = 0; i < Config::get().skinItems; i++) 353 | { 354 | Config::get().cfgWeapons[i].weaponName = LocalPlayer::get().get_weapon_name2(i); 355 | Config::get().cfgWeapons[i].skinId = fade; 356 | Config::get().cfgWeapons[i].wear = 0.01f; 357 | Config::get().cfgWeapons[i].seed = 0.01f; 358 | Config::get().cfgWeapons[i].statTrack = 1337; 359 | Config::get().cfgWeapons[i].customName.resize(32); 360 | Config::get().cfgWeapons[i].customName = "SUKA TI EBENAYA"; 361 | } 362 | once = false; 363 | } 364 | ImGui::Combo("weapons", &Config::get().currComboWeaponSkin, Config::get().skinchanger_skins, sizeof(Config::get().skinchanger_skins) / sizeof(Config::get().skinchanger_skins[0]), sizeof(Config::get().skinchanger_skins) / sizeof(Config::get().skinchanger_skins[0])); 365 | ImGui::Combo("skins", &Config::get().cfgWeapons[Config::get().currComboWeaponSkin].currComboSelect, Config::get().skins, sizeof(Config::get().skins) / sizeof(Config::get().skins[0]), sizeof(Config::get().skins) / sizeof(Config::get().skins[0])); 366 | ImGui::SliderFloat("wear", &Config::get().cfgWeapons[Config::get().currComboWeaponSkin].wear, 0.f, 1.f, "%f"); 367 | 368 | ImGui::ColorPicker4("checkboxes color", Config::get().menuCheckboxesColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 369 | ImGui::ColorPicker4("checkboxes active color", Config::get().menuCheckedCBoxes, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 370 | ImGui::ColorPicker4("checkboxes warning color", Config::get().menuCheckboxWarningColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 371 | ImGui::ColorPicker4("frame color", Config::get().menuFrameColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 372 | ImGui::ColorPicker4("childs color", Config::get().menuChildColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 373 | ImGui::ColorPicker4("button color", Config::get().menuButtonColor, ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_InputRGB); 374 | ImGui::EndChild(); 375 | 376 | 377 | style.WindowPadding = ImVec2(0, 0); 378 | style.ItemInnerSpacing = ImVec2(1, 1); 379 | style.ItemSpacing = ImVec2(1, 1); 380 | } 381 | 382 | 383 | 384 | extern LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); 385 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # This application reads/writes the process memory of CS:GO 2 | ## Based on DirectX 9.0 + DearImGUI 3 | ## Run csgo.exe BEFORE the cheat application 4 | ### Usage 5 | * to open menu -> press insert button 6 | * to use wallhack -> enable esp checkbox functionality 7 | * to use trigger/aim -> enable legitbot checkbox 8 | # FOV function is broken ( special for open source, to fix -> 1 clamp function ) 9 | # Showcase : 10 | [![](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS_OH15R3m8auksJo9XRhR5vQqjjw7QLQSuqw&usqp=CAU)](https://www.youtube.com/watch?v=9CN-mEQyeF4&t=0s) 11 | --------------------------------------------------------------------------------