├── .gitattributes ├── LICENSE ├── README.md ├── base.sln ├── cs2.png ├── cs2.webp ├── cstrike ├── CS2GunIcons.ttf ├── common.h ├── core.cpp ├── core.h ├── core │ ├── Bgs.h │ ├── Header.h │ ├── ImFont.h │ ├── config.cpp │ ├── config.h │ ├── convars.cpp │ ├── convars.h │ ├── csig │ │ ├── sigscan.cpp │ │ └── sigscan.hpp │ ├── fnv1a.hpp │ ├── gui.cpp │ ├── gui.hpp │ ├── hooks.cpp │ ├── hooks.h │ ├── imfonts.h │ ├── interfaces.cpp │ ├── interfaces.h │ ├── memaddon.hpp │ ├── memory │ │ ├── cmodule.cpp │ │ ├── cmodule.hpp │ │ ├── memadd.cpp │ │ └── memadd.h │ ├── menu.cpp │ ├── menu.h │ ├── pointer │ │ ├── pointer.cpp │ │ └── pointer.hpp │ ├── schema.cpp │ ├── schema.h │ ├── schemav2.cpp │ ├── schemav2.hpp │ ├── sdk.cpp │ ├── sdk.h │ ├── silentvmt │ │ ├── InlineHook.cpp │ │ ├── InlineHook.h │ │ ├── ShadowVMT.cpp │ │ └── ShadowVMT.h │ ├── spoofcall │ │ ├── SpoofCall.asm │ │ ├── Utils.h │ │ ├── callstack.cpp │ │ ├── callstack.h │ │ ├── callstack.hpp │ │ ├── invoker.h │ │ ├── lazy_importer.hpp │ │ ├── syscall.h │ │ └── virtualization │ │ │ ├── VirtualizerSDK64.asm │ │ │ ├── VirtualizerSDK64.h │ │ │ └── VirtualizerSDK64.inc │ ├── stb.hh │ ├── stdafx.h │ ├── ui_icons.hpp │ ├── variables.cpp │ └── variables.h ├── cstrike.vcxproj ├── cstrike.vcxproj.filters ├── cstrike.vcxproj.user ├── features.cpp ├── features.h ├── features │ ├── antiaim │ │ ├── antiaim.cpp │ │ └── antiaim.hpp │ ├── enginepred │ │ ├── pred.cpp │ │ └── pred.h │ ├── lagcomp │ │ ├── lagcomp.cpp │ │ └── lagcomp.h │ ├── legit │ │ ├── legit.cpp │ │ └── legit.h │ ├── misc.cpp │ ├── misc.h │ ├── misc │ │ ├── movement.cpp │ │ └── movement.h │ ├── penetration │ │ ├── penetration.cpp │ │ └── penetration.h │ ├── post_processing.cpp │ ├── post_processing.hpp │ ├── rage │ │ ├── rage.cpp │ │ └── rage.h │ ├── skins │ │ ├── ccsinventorymanager.cpp │ │ ├── ccsinventorymanager.hpp │ │ ├── ccsplayerinventory.cpp │ │ ├── ccsplayerinventory.hpp │ │ ├── skin_changer.cpp │ │ └── skin_changer.hpp │ ├── visuals.cpp │ ├── visuals.h │ └── visuals │ │ ├── chams.cpp │ │ ├── chams.h │ │ ├── overlay.cpp │ │ └── overlay.h ├── font.h ├── icons │ ├── ak47.svg │ ├── aug.svg │ ├── awp.svg │ ├── bayonet.svg │ ├── bizon.svg │ ├── bomb.svg │ ├── c4.svg │ ├── cz75a.svg │ ├── deagle.svg │ ├── decoy.svg │ ├── elite.svg │ ├── famas.svg │ ├── fiveseven.svg │ ├── flashbang.svg │ ├── flashed_kill.svg │ ├── g3sg1.svg │ ├── galilar.svg │ ├── glock.svg │ ├── headshot.svg │ ├── hegrenade.svg │ ├── hkp2000.svg │ ├── icon_defuse_default.svg │ ├── iconscs2.c │ ├── iconscs2.ttf │ ├── incgrenade0.svg │ ├── knife.svg │ ├── knife_bayonet.svg │ ├── knife_butterfly.svg │ ├── knife_canis.svg │ ├── knife_cord.svg │ ├── knife_css.svg │ ├── knife_falchion.svg │ ├── knife_flip.svg │ ├── knife_gut.svg │ ├── knife_gypsy_jackknife.svg │ ├── knife_karambit.svg │ ├── knife_m9_bayonet.svg │ ├── knife_outdoor.svg │ ├── knife_push.svg │ ├── knife_skeleton.svg │ ├── knife_stiletto.svg │ ├── knife_survival_bowie.svg │ ├── knife_t.svg │ ├── knife_tactical.svg │ ├── knife_ursus.svg │ ├── knife_widowmaker.svg │ ├── m249.svg │ ├── m4a1.svg │ ├── m4a1_silencer.svg │ ├── m4a1_silencer_off.svg │ ├── mac10.svg │ ├── mag7.svg │ ├── molotov.svg │ ├── mp5sd.svg │ ├── mp7.svg │ ├── mp9.svg │ ├── negev.svg │ ├── noscope.svg │ ├── nova.svg │ ├── obs_icons.ttf │ ├── out.svg │ ├── p250.svg │ ├── p90.svg │ ├── revolver.svg │ ├── sawedoff.svg │ ├── scar20.svg │ ├── sg556.svg │ ├── smoke_kill.svg │ ├── smokegrenade.svg │ ├── ssg08.svg │ ├── taser.svg │ ├── tec9.svg │ ├── ump451.svg │ ├── usp_silencer.svg │ ├── usp_silencer_off.svg │ └── xm1014.svg ├── multidrop.h ├── sdk │ ├── const.h │ ├── datatypes │ │ ├── K3V.cpp │ │ ├── K3V.h │ │ ├── buf │ │ │ ├── strtools.cpp │ │ │ ├── strtools.h │ │ │ ├── utlbuffer.cpp │ │ │ ├── utlbuffer.h │ │ │ └── wchartypes.h │ │ ├── byteswap.h │ │ ├── cinterlockedint.hpp │ │ ├── color.h │ │ ├── cstronghandle.hpp │ │ ├── datamap.h │ │ ├── matrix.cpp │ │ ├── matrix.h │ │ ├── qangle.cpp │ │ ├── qangle.h │ │ ├── quaternion.h │ │ ├── repfieldcontainer.h │ │ ├── resourcebinding_t.hpp │ │ ├── resourceutils.h │ │ ├── stronghandle.hpp │ │ ├── transform.h │ │ ├── usercmd.h │ │ ├── utlfixedmemory.h │ │ ├── utllinkedlist.h │ │ ├── utlmap.h │ │ ├── utlmemory.h │ │ ├── utlrbtree.h │ │ ├── utlstring.h │ │ ├── utlstringtoken.h │ │ ├── utlthash.h │ │ ├── utlvector.h │ │ ├── vector.cpp │ │ ├── vector.h │ │ └── viewsetup.h │ ├── entity.cpp │ ├── entity.h │ ├── entity_handle.cpp │ ├── entity_handle.h │ └── interfaces │ │ ├── ccsgoinput.cpp │ │ ├── ccsgoinput.h │ │ ├── cgameentitysystem.h │ │ ├── events.cpp │ │ ├── events.h │ │ ├── idebugoverlay.h │ │ ├── iengineclient.cpp │ │ ├── iengineclient.h │ │ ├── ienginecvar.h │ │ ├── igameresourceservice.h │ │ ├── iglobalvars.h │ │ ├── iinputsystem.h │ │ ├── imaterialsystem.h │ │ ├── imemalloc.h │ │ ├── inetworkclientservice.h │ │ ├── ischemasystem.h │ │ ├── iswapchaindx11.h │ │ ├── itrace.cpp │ │ ├── itrace.h │ │ └── iviewrender.h ├── texture.h └── utilities │ ├── crt.h │ ├── detourhook.h │ ├── draw.cpp │ ├── draw.h │ ├── easing.h │ ├── fnv1a.h │ ├── inputsystem.cpp │ ├── inputsystem.h │ ├── log.cpp │ ├── log.h │ ├── math.cpp │ ├── math.h │ ├── memory.cpp │ ├── memory.h │ ├── notify.cpp │ ├── notify.h │ └── pe64.h ├── dependencies ├── freetype │ ├── binary │ │ ├── freetype.lib │ │ └── freetype_debug.lib │ └── include │ │ ├── freetype │ │ ├── config │ │ │ ├── ftconfig.h │ │ │ ├── ftheader.h │ │ │ ├── ftmodule.h │ │ │ ├── ftoption.h │ │ │ └── ftstdlib.h │ │ ├── freetype.h │ │ ├── ftadvanc.h │ │ ├── ftbbox.h │ │ ├── ftbdf.h │ │ ├── ftbitmap.h │ │ ├── ftbzip2.h │ │ ├── ftcache.h │ │ ├── ftchapters.h │ │ ├── ftcid.h │ │ ├── ftcolor.h │ │ ├── ftdriver.h │ │ ├── fterrdef.h │ │ ├── fterrors.h │ │ ├── ftfntfmt.h │ │ ├── ftgasp.h │ │ ├── ftglyph.h │ │ ├── ftgxval.h │ │ ├── ftgzip.h │ │ ├── ftimage.h │ │ ├── ftincrem.h │ │ ├── ftlcdfil.h │ │ ├── ftlist.h │ │ ├── ftlzw.h │ │ ├── ftmac.h │ │ ├── ftmm.h │ │ ├── ftmodapi.h │ │ ├── ftmoderr.h │ │ ├── ftotval.h │ │ ├── ftoutln.h │ │ ├── ftparams.h │ │ ├── ftpfr.h │ │ ├── ftrender.h │ │ ├── ftsizes.h │ │ ├── ftsnames.h │ │ ├── ftstroke.h │ │ ├── ftsynth.h │ │ ├── ftsystem.h │ │ ├── fttrigon.h │ │ ├── fttypes.h │ │ ├── ftwinfnt.h │ │ ├── internal │ │ │ ├── autohint.h │ │ │ ├── cffotypes.h │ │ │ ├── cfftypes.h │ │ │ ├── ftcalc.h │ │ │ ├── ftdebug.h │ │ │ ├── ftdrv.h │ │ │ ├── ftgloadr.h │ │ │ ├── fthash.h │ │ │ ├── ftmemory.h │ │ │ ├── ftobjs.h │ │ │ ├── ftpsprop.h │ │ │ ├── ftrfork.h │ │ │ ├── ftserv.h │ │ │ ├── ftstream.h │ │ │ ├── fttrace.h │ │ │ ├── ftvalid.h │ │ │ ├── internal.h │ │ │ ├── psaux.h │ │ │ ├── pshints.h │ │ │ ├── services │ │ │ │ ├── svbdf.h │ │ │ │ ├── svcfftl.h │ │ │ │ ├── svcid.h │ │ │ │ ├── svfntfmt.h │ │ │ │ ├── svgldict.h │ │ │ │ ├── svgxval.h │ │ │ │ ├── svkern.h │ │ │ │ ├── svmetric.h │ │ │ │ ├── svmm.h │ │ │ │ ├── svotval.h │ │ │ │ ├── svpfr.h │ │ │ │ ├── svpostnm.h │ │ │ │ ├── svprop.h │ │ │ │ ├── svpscmap.h │ │ │ │ ├── svpsinfo.h │ │ │ │ ├── svsfnt.h │ │ │ │ ├── svttcmap.h │ │ │ │ ├── svtteng.h │ │ │ │ ├── svttglyf.h │ │ │ │ └── svwinfnt.h │ │ │ ├── sfnt.h │ │ │ ├── t1types.h │ │ │ └── tttypes.h │ │ ├── t1tables.h │ │ ├── ttnameid.h │ │ ├── tttables.h │ │ └── tttags.h │ │ └── ft2build.h ├── imgui │ ├── imconfig.h │ ├── imgui.cpp │ ├── imgui.h │ ├── imgui_demo.cpp │ ├── imgui_draw.cpp │ ├── imgui_edited.cpp │ ├── imgui_edited.hpp │ ├── imgui_freetype.cpp │ ├── imgui_freetype.h │ ├── imgui_impl_dx11.cpp │ ├── imgui_impl_dx11.h │ ├── imgui_impl_win32.cpp │ ├── imgui_impl_win32.h │ ├── imgui_internal.h │ ├── imgui_settings.h │ ├── imgui_tables.cpp │ ├── imgui_widgets.cpp │ ├── imstb_rectpack.h │ ├── imstb_textedit.h │ └── imstb_truetype.h ├── imgui_notify.h ├── json.hpp ├── minhook │ ├── buffer.c │ ├── buffer.h │ ├── hde │ │ ├── hde32.c │ │ ├── hde32.h │ │ ├── hde64.c │ │ ├── hde64.h │ │ ├── pstdint.h │ │ ├── table32.h │ │ └── table64.h │ ├── hook.c │ ├── minhook.h │ ├── trampoline.c │ └── trampoline.h ├── stb_image.h ├── stb_sprintf.h └── xorstr.h ├── extensions ├── binary.h └── json.h ├── resources ├── README.md ├── fa_solid_900.h ├── font_awesome_5.h ├── game_icons.h └── smallest_pixel.h └── sddefault.jpg /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2024 T1GXR 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Axion-CS2-RAGE-CHEAT 2 | + The source code of AXION CS2 internal rage cheat. 3 | + It's made on asphyxia base and has some features implemented from csgo cheats like Pandora. 4 | + I decided to make it public beacause it has been sold for 75$ and then leaked on the internet. 5 | + It has some great features but it can't be used for hvh because its preety buggy. 6 | + The cheat might get you VAC banned so only use it at your own risk (better on non prime accounts). 7 | 8 | # Status: Needs update! 9 | I don't have time to work on it anymore because of lack of time and other personal projects but I'll let it for the community. 10 | 11 | If you are trying to fix it, you have to: 12 | - Update the schema (take it from asphyxia because it's the same) 13 | - Update the signatures (You can find them in hooks.cpp/hooks.h). 14 | - Make sure you build it on publish and not on release. (If you build on release you will get a lot of errors) 15 | - Make sure you include everything required in the project settings! 16 | 17 | # PREVIEW 18 | ![Screenshot 2024-04-14 175107](https://github.com/T1GxR/AxionCS2-RAGE-CHEAT/assets/106729571/df318ac7-1723-43c0-bc00-d5900812df52) 19 | ![Screenshot 2024-04-14 175057](https://github.com/T1GxR/AxionCS2-RAGE-CHEAT/assets/106729571/2496ee46-667e-47b6-b1c7-8c97c18f88bf) 20 | ![Screenshot 2024-04-14 175032](https://github.com/T1GxR/AxionCS2-RAGE-CHEAT/assets/106729571/719246a9-4812-4134-a269-efadf648d78c) 21 | ![Screenshot 2024-04-14 175018](https://github.com/T1GxR/AxionCS2-RAGE-CHEAT/assets/106729571/3f80c0a0-96f4-432f-b55f-e2232297b323) 22 | ![Screenshot 2024-04-14 175010](https://github.com/T1GxR/AxionCS2-RAGE-CHEAT/assets/106729571/7535baf2-577a-4ae5-8bd3-39cf2a53a6d6) 23 | 24 | # Features: 25 | + RAGE BOT: 26 | - Rapid Fire 27 | - Anti Aim (Jitter) 28 | - Multipoint 29 | - PSilent 30 | + Visual: 31 | - ESP (BOX, SKELETON AND MORE) 32 | - CHAMS 33 | - ITEM ESP 34 | - FLAGS 35 | - FOV changer 36 | + Misc: 37 | - Night mode 38 | - Sky box changer 39 | - No flash 40 | - No smoke 41 | - Third person 42 | - No impact 43 | + Other features: 44 | - Inventory changer with item dump 45 | - In game skin changer 46 | - Configs tab (Path: Documents/.cs2/settings) 47 | - Plant bomb anywhere (only works at the beginning of the round for a second only) 48 | - AND MORE 49 | 50 | # TO-DO 51 | + Improve the rage tab and some miscellaneous features because they were created to manipulate the game server and they only work on local games/practice games. Basically on higher ping games, the rage is completely useless, as well as bhop which makes the character fly while holding space. All those bugs can be fixed if you know what to do. 52 | 53 | -------------------------------------------------------------------------------- /base.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 16 4 | VisualStudioVersion = 16.0.33801.447 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cstrike", "cstrike\cstrike.vcxproj", "{DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Developer|x64 = Developer|x64 12 | Distrib|x64 = Distrib|x64 13 | Publish|x64 = Publish|x64 14 | Release|x64 = Release|x64 15 | EndGlobalSection 16 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 17 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Debug|x64.ActiveCfg = Debug|x64 18 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Debug|x64.Build.0 = Debug|x64 19 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Developer|x64.ActiveCfg = Developer|x64 20 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Developer|x64.Build.0 = Developer|x64 21 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Distrib|x64.ActiveCfg = Distrib|x64 22 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Distrib|x64.Build.0 = Distrib|x64 23 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Publish|x64.ActiveCfg = Publish|x64 24 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Publish|x64.Build.0 = Publish|x64 25 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Release|x64.ActiveCfg = Release|x64 26 | {DAC639DD-46A6-B878-4FBE-434FBB1C1FDA}.Release|x64.Build.0 = Release|x64 27 | EndGlobalSection 28 | GlobalSection(SolutionProperties) = preSolution 29 | HideSolutionNode = FALSE 30 | EndGlobalSection 31 | GlobalSection(ExtensibilityGlobals) = postSolution 32 | SolutionGuid = {0BA324F3-F438-4261-89D4-5AF13CD1FA32} 33 | EndGlobalSection 34 | EndGlobal 35 | -------------------------------------------------------------------------------- /cs2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cs2.png -------------------------------------------------------------------------------- /cs2.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cs2.webp -------------------------------------------------------------------------------- /cstrike/CS2GunIcons.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/CS2GunIcons.ttf -------------------------------------------------------------------------------- /cstrike/core.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace CORE 4 | { 5 | /* @section: get */ 6 | /// @param[out] wszDestination output for working path where files will be saved (default: "%userprofile%\documents\.crown") 7 | /// @returns: true if successfully got the path, false otherwise 8 | bool GetWorkingPath(wchar_t* wszDestination); 9 | 10 | /* @section: values */ 11 | // handle of self module 12 | inline void* hDll = nullptr; 13 | // current process handle 14 | inline void* hProcess = nullptr; 15 | } -------------------------------------------------------------------------------- /cstrike/core/convars.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CConVar; 4 | 5 | namespace CONVAR 6 | { 7 | // dump convars to file 8 | bool Dump(const wchar_t* wszFileName); 9 | // setup convars 10 | bool Setup(); 11 | 12 | inline CConVar* m_pitch = nullptr; 13 | inline CConVar* m_yaw = nullptr; 14 | inline CConVar* sensitivity = nullptr; 15 | 16 | inline CConVar* game_type = nullptr; 17 | inline CConVar* game_mode = nullptr; 18 | 19 | inline CConVar* mp_teammates_are_enemies = nullptr; 20 | 21 | inline CConVar* sv_autobunnyhopping = nullptr; 22 | 23 | inline CConVar* cam_idealdist = nullptr; 24 | 25 | inline CConVar* cam_collision = nullptr; 26 | 27 | inline CConVar* cam_snapto = nullptr; 28 | 29 | inline CConVar* c_thirdpersonshoulder = nullptr; 30 | 31 | inline CConVar* c_thirdpersonshoulderaimdist = nullptr; 32 | 33 | inline CConVar* c_thirdpersonshoulderdist = nullptr; 34 | 35 | inline CConVar* c_thirdpersonshoulderheight = nullptr; 36 | 37 | inline CConVar* c_thirdpersonshoulderoffset = nullptr; 38 | 39 | inline CConVar* cl_interpolate = nullptr; 40 | 41 | inline CConVar* cl_interp_ratio = nullptr; 42 | } 43 | -------------------------------------------------------------------------------- /cstrike/core/csig/sigscan.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "sigscan.hpp" 3 | #include "../../utilities/log.h" 4 | #include "../memory/memadd.h" 5 | CSigScan::CSigScan(const char* name, const char* libraryName, const std::initializer_list& data) { 6 | #ifdef SDK_ENABLE_LOGGING 7 | m_Name = name; 8 | #else 9 | m_Name = ""; 10 | #endif 11 | 12 | m_LibraryName = libraryName; 13 | 14 | m_Data.reserve(data.size()); 15 | m_Data.insert(m_Data.end(), data.begin(), data.end()); 16 | 17 | CSigScanManager::Get().ScheduleScan(this); 18 | } 19 | 20 | void CSigScan::FindSignature() { 21 | auto& library = CMemory::GetModule(m_LibraryName); 22 | if (!library) { 23 | L_PRINT(LOG_WARNING) << CS_XOR("\"signature\" Couldn't find {} because {} was not loaded."); 24 | } 25 | 26 | for (size_t i = 0; i < m_Data.size(); ++i) { 27 | // Faster than m_Data[] in debug builds because of _STL_VERIFY. 28 | const auto& data = m_Data.data()[i]; 29 | 30 | m_Value = library->FindPattern(data.m_Signature); 31 | if (m_Value.IsValid()) { 32 | if (data.m_Procedure) { 33 | data.m_Procedure(m_Value); 34 | } 35 | 36 | L_PRINT(LOG_INFO) << CS_XOR("\"signature\" Couldn't find " << m_Name << " because{} " << m_Value.Get() << "was not loaded " << i << " | index."); 37 | } 38 | } 39 | 40 | L_PRINT(LOG_ERROR) << CS_XOR("\"signature\" Couldn't find "); 41 | 42 | } 43 | 44 | void CSigScanManager::ScheduleScan(CSigScan* sigScan) { m_ScheduledScans.emplace_back(sigScan); } 45 | 46 | void CSigScanManager::ProcessScans() { 47 | for (size_t i = 0; i < m_ScheduledScans.size(); ++i) { 48 | // Faster than m_ScheduledScans[] in debug builds because of _STL_VERIFY. 49 | const auto& scheduledScan = m_ScheduledScans.data()[i]; 50 | 51 | scheduledScan->FindSignature(); 52 | scheduledScan->FreeData(); 53 | } 54 | 55 | // No need to keep the scans in memory if we're done with them. 56 | std::vector().swap(m_ScheduledScans); 57 | } 58 | -------------------------------------------------------------------------------- /cstrike/core/csig/sigscan.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../pointer/pointer.hpp" 4 | #include 5 | #include 6 | 7 | class CSigScan { 8 | public: 9 | using ProcedureFn = std::function; 10 | 11 | struct SigData_t { 12 | std::span m_Signature; 13 | ProcedureFn m_Procedure; 14 | }; 15 | 16 | CSigScan(const char* name, const char* libraryName, const std::initializer_list& data); 17 | 18 | void FindSignature(); 19 | auto FreeData() { std::vector().swap(m_Data); } 20 | 21 | auto GetPtr() const { return m_Value; } 22 | 23 | template 24 | auto GetPtrAs() const { 25 | return m_Value.Get(); 26 | } 27 | 28 | CSigScan(const CSigScan&) = delete; 29 | CSigScan& operator=(const CSigScan&) = delete; 30 | 31 | private: 32 | const char* m_Name; 33 | const char* m_LibraryName; 34 | 35 | std::vector m_Data; 36 | 37 | CPointer m_Value; 38 | }; 39 | 40 | class CSigScanManager { 41 | public: 42 | static CSigScanManager& Get() { 43 | static CSigScanManager inst; 44 | return inst; 45 | } 46 | 47 | void ScheduleScan(CSigScan* sigScan); 48 | void ProcessScans(); 49 | 50 | private: 51 | std::vector m_ScheduledScans; 52 | }; 53 | -------------------------------------------------------------------------------- /cstrike/core/fnv1a.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace fnv1a { 4 | constexpr uint32_t Hash(const char* str) noexcept { return (*str ? (Hash(str + 1) ^ *str) * 0x01000193 : 0x811c9dc5); } 5 | } // namespace fnv1a 6 | -------------------------------------------------------------------------------- /cstrike/core/gui.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/gui.cpp -------------------------------------------------------------------------------- /cstrike/core/gui.hpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/gui.hpp -------------------------------------------------------------------------------- /cstrike/core/memory/cmodule.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | class CModule { 6 | public: 7 | CModule(const char* name); 8 | ~CModule(); 9 | 10 | auto GetHash() const { return m_Hash; } 11 | auto GetHandle() const { return m_Handle; } 12 | auto GetName() const { return m_Name.c_str(); } 13 | 14 | // Returns false if module not loaded. 15 | bool Retrieve(); 16 | 17 | uintptr_t GetInterface(const char* version); 18 | uintptr_t GetProcAddress(const char* procName); 19 | uintptr_t FindPattern(const std::span& pattern) const; 20 | 21 | private: 22 | void InitializeHandle(); 23 | void InitializeBounds(); 24 | 25 | void SetBounds(uintptr_t begin, uintptr_t size); 26 | 27 | // Module name. 28 | std::string m_Name; 29 | 30 | // Module name fnv1a hash. 31 | uint32_t m_Hash; 32 | 33 | // Module handle. 34 | void* m_Handle; 35 | 36 | // Used for pattern scanning. 37 | uintptr_t m_Begin, m_Size; 38 | }; 39 | -------------------------------------------------------------------------------- /cstrike/core/memory/memadd.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include "../memory/memadd.h" 4 | #include "../csig/sigscan.hpp" 5 | #include "../fnv1a.hpp" 6 | void CMemory::Initialize() { 7 | 8 | for (CSigScan* it : m_ScheduledScans) { 9 | it->FindSignature(); 10 | it->FreeData(); 11 | } 12 | 13 | std::vector().swap(m_ScheduledScans); 14 | } 15 | 16 | ModulePtr_t& CMemory::GetModuleInternal(const char* libName) { 17 | auto hash = fnv1a::Hash(libName); 18 | 19 | auto it = m_CachedModules.find(hash); 20 | if (it != m_CachedModules.end()) { 21 | return it->second; 22 | } 23 | 24 | auto module = std::make_unique(libName); 25 | if (module->Retrieve()) { 26 | return m_CachedModules.emplace(hash, std::move(module)).first->second; 27 | } 28 | 29 | 30 | static ModulePtr_t null{}; 31 | return null; 32 | } 33 | 34 | CPointer CMemory::GetInterfaceInternal(const char* libName, const char* version) { 35 | CPointer rv = 0; 36 | 37 | auto& library = CMemory::GetModuleInternal(libName); 38 | if (!library) { 39 | return rv; 40 | } 41 | 42 | rv = library->GetInterface(version); 43 | 44 | return rv; 45 | } 46 | 47 | CPointer CMemory::GetProcAddressInternal(const char* libName, const char* procName) { 48 | CPointer rv = 0; 49 | 50 | auto& library = CMemory::GetModuleInternal(libName); 51 | if (!library) { 52 | return rv; 53 | } 54 | 55 | rv = library->GetProcAddress(procName); 56 | 57 | return rv; 58 | } 59 | -------------------------------------------------------------------------------- /cstrike/core/memory/memadd.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../memory/cmodule.hpp" 4 | #include "../pointer/pointer.hpp" 5 | #include 6 | #include 7 | #include 8 | 9 | class CSigScan; 10 | 11 | using ModulePtr_t = std::unique_ptr; 12 | 13 | class CMemory { 14 | public: 15 | static CMemory& Get() { 16 | static CMemory inst; 17 | return inst; 18 | } 19 | 20 | static auto& GetModule(const char* libName) { return Get().GetModuleInternal(libName); } 21 | static auto GetInterface(const char* libName, const char* version) { return Get().GetInterfaceInternal(libName, version); } 22 | static auto GetProcAddress(const char* libName, const char* procName) { return Get().GetProcAddressInternal(libName, procName); } 23 | 24 | // Used internally. 25 | static auto ScheduleScan(CSigScan* sigScan) { Get().m_ScheduledScans.emplace_back(sigScan); } 26 | 27 | void Initialize(); 28 | 29 | private: 30 | ModulePtr_t& GetModuleInternal(const char* libName); 31 | 32 | CPointer GetInterfaceInternal(const char* libName, const char* version); 33 | CPointer GetProcAddressInternal(const char* libName, const char* procName); 34 | 35 | std::unordered_map m_CachedModules; 36 | std::vector m_ScheduledScans; 37 | }; 38 | -------------------------------------------------------------------------------- /cstrike/core/pointer/pointer.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "pointer.hpp" 3 | #include 4 | 5 | CPointer CPointer::GetFieldPtr(int offset) const { 6 | if (IsValid()) { 7 | return m_Value + offset; 8 | } 9 | 10 | LogInvalid(); 11 | 12 | static CPointer null{}; 13 | return &null; 14 | } 15 | 16 | CPointer& CPointer::Offset(int offset) { 17 | if (IsValid()) { 18 | m_Value += offset; 19 | } 20 | 21 | return *this; 22 | } 23 | 24 | CPointer& CPointer::Absolute(int preAbs, int postAbs) { 25 | if (IsValid()) { 26 | Offset(preAbs); 27 | m_Value = m_Value + sizeof(int) + *reinterpret_cast(m_Value); 28 | Offset(postAbs); 29 | } 30 | 31 | return *this; 32 | } 33 | 34 | CPointer& CPointer::Dereference(int count) { 35 | if (IsValid()) { 36 | while (count-- != 0) { 37 | m_Value = *reinterpret_cast(m_Value); 38 | } 39 | } 40 | 41 | return *this; 42 | } 43 | 44 | void CPointer::LogInvalid() const { std::cout << "invalid offset\n"; } 45 | -------------------------------------------------------------------------------- /cstrike/core/pointer/pointer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | class CPointer { 5 | public: 6 | CPointer() { m_Value = 0; } 7 | 8 | template 9 | CPointer(T value) { 10 | m_Value = (uintptr_t)(value); 11 | } 12 | 13 | bool IsValid() const { return m_Value != 0; } 14 | 15 | template 16 | auto Get() const { 17 | return reinterpret_cast(m_Value); 18 | } 19 | 20 | template 21 | std::add_lvalue_reference_t GetField(int offset) const { 22 | return *GetFieldPtr(offset).Get(); 23 | } 24 | 25 | template 26 | auto Call(Args... args) const { 27 | if constexpr (std::is_invocable_v) { 28 | if (IsValid()) { 29 | return std::invoke(Get(), std::forward(args)...); 30 | } 31 | } else { 32 | static_assert(std::is_invocable_v, "T must be an invocable type."); 33 | } 34 | 35 | LogInvalid(); 36 | return std::invoke_result_t{}; 37 | } 38 | 39 | CPointer GetFieldPtr(int offset) const; 40 | 41 | CPointer& Offset(int offset); 42 | CPointer& Absolute(int preAbs, int postAbs); 43 | CPointer& Dereference(int count); 44 | 45 | private: 46 | void LogInvalid() const; 47 | 48 | uintptr_t m_Value; 49 | }; 50 | -------------------------------------------------------------------------------- /cstrike/core/schema.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | 4 | #include "../common.h" 5 | 6 | // used: fnv-1a hash 7 | #include "../utilities/fnv1a.h" 8 | 9 | #define SCHEMA_ADD_OFFSET(TYPE, NAME, OFFSET) \ 10 | [[nodiscard]] CS_INLINE std::add_lvalue_reference_t NAME() \ 11 | { \ 12 | static const std::uint32_t uOffset = OFFSET; \ 13 | return *reinterpret_cast>(reinterpret_cast(this) + (uOffset)); \ 14 | } 15 | 16 | #define SCHEMA_ADD_POFFSET(TYPE, NAME, OFFSET) \ 17 | [[nodiscard]] CS_INLINE std::add_pointer_t NAME() \ 18 | { \ 19 | const static std::uint32_t uOffset = OFFSET; \ 20 | return reinterpret_cast>(reinterpret_cast(this) + (uOffset)); \ 21 | } 22 | 23 | #define SCHEMA_ADD_FIELD_OFFSET(TYPE, NAME, FIELD, ADDITIONAL) SCHEMA_ADD_OFFSET(TYPE, NAME, SCHEMA::GetOffset(FNV1A::HashConst(FIELD)) + ADDITIONAL) 24 | 25 | #define SCHEMA_ADD_FIELD(TYPE, NAME, FIELD) SCHEMA_ADD_FIELD_OFFSET(TYPE, NAME, FIELD, 0U) 26 | 27 | #define SCHEMA_ADD_PFIELD_OFFSET(TYPE, NAME, FIELD, ADDITIONAL) SCHEMA_ADD_POFFSET(TYPE, NAME, SCHEMA::GetOffset(FNV1A::HashConst(FIELD)) + ADDITIONAL) 28 | 29 | #define SCHEMA_ADD_PFIELD(TYPE, NAME, FIELD) SCHEMA_ADD_PFIELD_OFFSET(TYPE, NAME, FIELD, 0U) 30 | 31 | // @todo: dump enums? 32 | namespace SCHEMA 33 | { 34 | // store the offset of the field in the class 35 | // dump stored data to file 36 | bool Setup(const wchar_t* wszFileName, const char* szModuleName); 37 | 38 | /* @section: get */ 39 | // get offset of the field in the class 40 | // @note: only client.dll class & fields 41 | [[nodiscard]] std::uint32_t GetOffset(const FNV1A_t uHashedFieldName); 42 | 43 | // get foregin offset from other .dll 44 | [[nodiscard]] std::uint32_t GetForeignOffset(const char* szModulenName, const FNV1A_t uHashedClassName, const FNV1A_t uHashedFieldName); 45 | } 46 | -------------------------------------------------------------------------------- /cstrike/core/schemav2.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "schemav2.hpp" 3 | #include "../sdk/interfaces/ischemasystem.h" 4 | #include "../utilities/fnv1a.h" 5 | #include "../utilities/log.h" 6 | 7 | std::optional CSchemaManager::GetSchemaOffsetInternal(const char* moduleName, const char* bindingName, const char* fieldName) { 8 | CSchemaSystemTypeScope* typeScope = I::SchemaSystem->FindTypeScopeForModule(moduleName); 9 | if (!typeScope) { 10 | L_PRINT(LOG_ERROR) << CS_XOR("\"schemamgr\" No type scope found for " << moduleName); 11 | return {}; 12 | } 13 | SchemaClassInfoData_t* classInfo; 14 | 15 | typeScope->FindDeclaredClass(&classInfo, bindingName); 16 | if (!classInfo) { 17 | L_PRINT(LOG_INFO) << CS_XOR("\"schemamgr\" No binding named '{}' has been found in module '{}'."); 18 | 19 | return {}; 20 | } 21 | 22 | uint32_t fieldHash = FNV1A::Hash(fieldName); 23 | for (int i = 0; classInfo->pFields && i < classInfo->nFieldSize; ++i) { 24 | auto& field = classInfo->pFields[i]; 25 | if (FNV1A::Hash(field.szName) == fieldHash) { 26 | L_PRINT(LOG_WARNING) << CS_XOR("\"schemamgr\" offset" << bindingName << "field: " << fieldName); 27 | 28 | return field.nSingleInheritanceOffset; 29 | } 30 | } 31 | L_PRINT(LOG_ERROR) << CS_XOR("\"schemamgr\" No field named " << fieldName << "in binding: " << bindingName); 32 | 33 | return {}; 34 | } 35 | -------------------------------------------------------------------------------- /cstrike/core/schemav2.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "pointer/pointer.hpp" 4 | 5 | #include 6 | class CSchemaManager { 7 | public: 8 | static CSchemaManager& Get() { 9 | static CSchemaManager inst; 10 | return inst; 11 | } 12 | 13 | static auto GetSchemaOffset(const char* moduleName, const char* bindingName, const char* fieldName) { 14 | return Get().GetSchemaOffsetInternal(moduleName, bindingName, fieldName); 15 | } 16 | 17 | private: 18 | std::optional GetSchemaOffsetInternal(const char* moduleName, const char* bindingName, const char* fieldName); 19 | }; 20 | 21 | #define SCHEMA_EXTENDED(type, name, module_name, binding_name, field_name, extra_offset) \ 22 | std::add_lvalue_reference_t name() const { \ 23 | static const auto offset = CSchemaManager::GetSchemaOffset(module_name, binding_name, field_name); \ 24 | if (offset) return CPointer(this).GetField(offset.value() + extra_offset); \ 25 | static type null{}; \ 26 | return null; \ 27 | } 28 | 29 | #define SCHEMA(type, name, binding_name, field_name) SCHEMA_EXTENDED(type, name, CConstants::CLIENT_LIB, binding_name, field_name, 0) 30 | 31 | #define PSCHEMA_EXTENDED(type, name, module_name, binding_name, field_name, extra_offset) \ 32 | std::add_pointer_t name() const { \ 33 | static const auto offset = CSchemaManager::GetSchemaOffset(module_name, binding_name, field_name); \ 34 | if (offset) return CPointer(this).GetFieldPtr(offset.value() + extra_offset).Get>(); \ 35 | return nullptr; \ 36 | } 37 | 38 | #define PSCHEMA(type, name, binding_name, field_name) PSCHEMA_EXTENDED(type, name, CConstants::CLIENT_LIB, binding_name, field_name, 0) 39 | -------------------------------------------------------------------------------- /cstrike/core/sdk.cpp: -------------------------------------------------------------------------------- 1 | #include "sdk.h" 2 | 3 | // used: getmodulebasehandle 4 | #include "../utilities/memory.h" 5 | 6 | bool SDK::Setup() 7 | { 8 | bool bSuccess = true; 9 | 10 | const void* hTier0Lib = MEM::GetModuleBaseHandle(TIER0_DLL); 11 | if (hTier0Lib == nullptr) 12 | return false; 13 | 14 | fnConColorMsg = reinterpret_cast(MEM::GetExportAddress(hTier0Lib, CS_XOR("?ConColorMsg@@YAXAEBVColor@@PEBDZZ"))); 15 | bSuccess &= fnConColorMsg != nullptr; 16 | 17 | return bSuccess; 18 | } 19 | -------------------------------------------------------------------------------- /cstrike/core/sdk.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: viewmatrix_t 4 | #include "../sdk/datatypes/matrix.h" 5 | // used: color_t 6 | #include "../sdk/datatypes/color.h" 7 | 8 | #pragma region sdk_definitions 9 | // @source: master/public/worldsize.h 10 | // world coordinate bounds 11 | #define MAX_COORD_FLOAT 16'384.f 12 | #define MIN_COORD_FLOAT (-MAX_COORD_FLOAT) 13 | 14 | // @source: master/public/vphysics_interface.h 15 | // coordinates are in HL units. 1 unit == 1 inch 16 | #define METERS_PER_INCH 0.0254f 17 | #pragma endregion 18 | 19 | class CCSPlayerController; 20 | class C_CSPlayerPawn; 21 | class CUserCmd; 22 | 23 | namespace SDK 24 | { 25 | // capture game's exported functions 26 | bool Setup(); 27 | 28 | inline ViewMatrix_t ViewMatrix = ViewMatrix_t(); 29 | inline Vector_t CameraPosition = Vector_t(); 30 | inline CCSPlayerController* LocalController = nullptr; 31 | inline C_CSPlayerPawn* LocalPawn = nullptr; 32 | inline CUserCmd* Cmd = nullptr; 33 | 34 | inline void(CS_CDECL* fnConColorMsg)(const Color_t&, const char*, ...) = nullptr; 35 | } 36 | 37 | class Cheat 38 | { 39 | public: 40 | bool onground = false; 41 | bool alive = false; 42 | bool canShot = false; 43 | bool canShotRevolver = false; 44 | unsigned int tickbase = 0; 45 | 46 | QAngle_t viewangles = QAngle_t(0, 0, 0); 47 | 48 | 49 | }; 50 | 51 | inline Cheat* cheat = new Cheat(); -------------------------------------------------------------------------------- /cstrike/core/silentvmt/InlineHook.cpp: -------------------------------------------------------------------------------- 1 | #include "InlineHook.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include "../cstrike/core/spoofcall/lazy_importer.hpp" 7 | bool detour(BYTE* src, BYTE* dst, const uintptr_t len) 8 | { 9 | if (len < 5) return false; 10 | DWORD curProtection; 11 | LI_FN(VirtualProtect).safe()(src, len, PAGE_EXECUTE_READWRITE, &curProtection); 12 | memset(src, 0x90, len); 13 | uintptr_t relativeAddress = ((uintptr_t)dst - (uintptr_t)src) - 5; 14 | *(BYTE*)src = 0xE9; 15 | *(uintptr_t*)((uintptr_t)src + 1) = relativeAddress; 16 | DWORD temp; 17 | LI_FN(VirtualProtect).safe()(src, len, curProtection, &temp); 18 | return true; 19 | } 20 | 21 | BYTE* trampHook(BYTE* src, BYTE* dst, const uintptr_t len) 22 | { 23 | if (len < 5) return 0; 24 | void* gateway = LI_FN(VirtualAlloc).safe()(0, len + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); 25 | memcpy(gateway, src, len); 26 | intptr_t gatewayRelativeAddr = ((intptr_t)src - (intptr_t)gateway) - 5; 27 | *(char*)((intptr_t)gateway + len) = 0xE9; 28 | *(intptr_t*)((intptr_t)gateway + len + 1) = gatewayRelativeAddr; 29 | // detour(src, dst, len); 30 | return (BYTE*) gateway; 31 | } 32 | 33 | void InlineHook::Hook(void* src, void* dest, const size_t len) 34 | { 35 | const BYTE* src_bytes = (BYTE*) src; 36 | 37 | for(int i = 0; i < len; i++) 38 | og_bytes.push_back(src_bytes[i]); 39 | 40 | source = (DWORD) src; 41 | 42 | original = (DWORD)trampHook((BYTE*) src, (BYTE*) dest, len); 43 | 44 | if(original) 45 | bEnabled = true; 46 | } 47 | 48 | void InlineHook::Unhook() 49 | { 50 | BYTE* bytes = (BYTE*) source; 51 | 52 | int i = 0; 53 | for(const BYTE& b : og_bytes) 54 | bytes[i++] = b; 55 | } -------------------------------------------------------------------------------- /cstrike/core/silentvmt/InlineHook.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | #include 39 | class InlineHook 40 | { 41 | std::vector og_bytes; 42 | DWORD original = 0; 43 | DWORD source = 0; 44 | bool bEnabled = false; 45 | public: 46 | InlineHook(){} 47 | 48 | void Hook(void* src, void* dest, const size_t len); 49 | void Unhook(); 50 | 51 | template 52 | T GetOg() 53 | { 54 | return (T)original; 55 | } 56 | }; 57 | -------------------------------------------------------------------------------- /cstrike/core/silentvmt/ShadowVMT.cpp: -------------------------------------------------------------------------------- 1 | #include "ShadowVMT.h" 2 | #include 3 | #include 4 | #include 5 | #include "../spoofcall/lazy_importer.hpp" 6 | ShadowVMT::ShadowVMT() 7 | : class_base(nullptr), vftbl_len(0), new_vftbl(nullptr), old_vftbl(nullptr) 8 | { 9 | } 10 | ShadowVMT::ShadowVMT(void* base) 11 | : class_base(base), vftbl_len(0), new_vftbl(nullptr), old_vftbl(nullptr) 12 | { 13 | } 14 | ShadowVMT::~ShadowVMT() 15 | { 16 | UnhookAll(); 17 | } 18 | 19 | bool ShadowVMT::Setup(void* base) 20 | { 21 | if(base != nullptr) 22 | class_base = base; 23 | 24 | if(class_base == nullptr) 25 | return false; 26 | 27 | old_vftbl = *(std::uintptr_t**)class_base; 28 | vftbl_len = CalcVtableLength(old_vftbl) * sizeof(std::uintptr_t); 29 | 30 | if(vftbl_len == 0) 31 | return false; 32 | 33 | new_vftbl = new std::uintptr_t[vftbl_len + 1](); 34 | 35 | std::memcpy(&new_vftbl[1], old_vftbl, vftbl_len * sizeof(std::uintptr_t)); 36 | 37 | try { 38 | DWORD old; 39 | LI_FN(VirtualProtect).safe()(class_base, sizeof(uintptr_t), PAGE_READWRITE, &old); 40 | new_vftbl[0] = old_vftbl[-1]; 41 | *(std::uintptr_t**)class_base = &new_vftbl[1]; 42 | LI_FN(VirtualProtect).safe()(class_base, sizeof(uintptr_t), old, &old); 43 | } catch(...) { 44 | delete[] new_vftbl; 45 | return false; 46 | } 47 | 48 | return true; 49 | } 50 | std::size_t ShadowVMT::CalcVtableLength(std::uintptr_t* vftbl_start) 51 | { 52 | MEMORY_BASIC_INFORMATION memInfo = { NULL }; 53 | int m_nSize = -1; 54 | do { 55 | m_nSize++; 56 | LI_FN( VirtualQuery).safe()(reinterpret_cast(vftbl_start[m_nSize]), &memInfo, sizeof(memInfo)); 57 | } while (memInfo.Protect == PAGE_EXECUTE_READ || memInfo.Protect == PAGE_EXECUTE_READWRITE); 58 | 59 | return m_nSize; 60 | } -------------------------------------------------------------------------------- /cstrike/core/silentvmt/ShadowVMT.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include 35 | #include 36 | #include 37 | #include 38 | class ShadowVMT 39 | { 40 | public: 41 | ShadowVMT(); 42 | ShadowVMT(void* base); 43 | ~ShadowVMT(); 44 | 45 | bool Setup(void* class_base = nullptr); 46 | 47 | template 48 | void HookIndex(int index, T fun) 49 | { 50 | new_vftbl[index + 1] = reinterpret_cast(fun); 51 | } 52 | void UnhookIndex(int index) 53 | { 54 | new_vftbl[index] = old_vftbl[index]; 55 | } 56 | void UnhookAll() 57 | { 58 | try { 59 | if (old_vftbl != nullptr) { 60 | DWORD old; 61 | VirtualProtect(class_base, sizeof(uintptr_t), PAGE_READWRITE, &old); 62 | *(std::uintptr_t**)class_base = old_vftbl; 63 | old_vftbl = nullptr; 64 | VirtualProtect(class_base, sizeof(uintptr_t), old, &old); 65 | } 66 | } 67 | catch (...) { 68 | } 69 | } 70 | 71 | template 72 | T GetOg(int index) 73 | { 74 | return (T)old_vftbl[index]; 75 | } 76 | 77 | private: 78 | inline std::size_t CalcVtableLength(std::uintptr_t* vftbl_start); 79 | 80 | void* class_base; 81 | std::size_t vftbl_len; 82 | std::uintptr_t* new_vftbl; 83 | std::uintptr_t* old_vftbl; 84 | }; -------------------------------------------------------------------------------- /cstrike/core/spoofcall/SpoofCall.asm: -------------------------------------------------------------------------------- 1 | PUBLIC _spoofer_stub 2 | 3 | .code 4 | 5 | _spoofer_stub PROC 6 | pop r11 7 | add rsp, 8 8 | mov rax, [rsp + 24] 9 | 10 | mov r10, [rax] 11 | mov [rsp], r10 12 | 13 | mov r10, [rax + 8] 14 | mov [rax + 8], r11 15 | 16 | mov [rax + 16], rbx 17 | lea rbx, fixup 18 | mov [rax], rbx 19 | mov rbx, rax 20 | 21 | jmp r10 22 | 23 | fixup: 24 | sub rsp, 16 25 | mov rcx, rbx 26 | mov rbx, [rcx + 16] 27 | jmp QWORD PTR [rcx + 8] 28 | _spoofer_stub ENDP 29 | 30 | END -------------------------------------------------------------------------------- /cstrike/core/spoofcall/Utils.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace detail 4 | { 5 | extern "C" void* _spoofer_stub(); 6 | 7 | template 8 | static inline auto shellcode_stub_helper( 9 | const void* shell, 10 | Args... args 11 | ) -> Ret 12 | { 13 | auto fn = (Ret(*)(Args...))(shell); 14 | return fn(args...); 15 | } 16 | 17 | template 18 | struct argument_remapper 19 | { 20 | // At least 5 params 21 | template< 22 | typename Ret, 23 | typename First, 24 | typename Second, 25 | typename Third, 26 | typename Fourth, 27 | typename... Pack 28 | > 29 | static auto do_call( 30 | const void* shell, 31 | void* shell_param, 32 | First first, 33 | Second second, 34 | Third third, 35 | Fourth fourth, 36 | Pack... pack 37 | ) -> Ret 38 | { 39 | return shellcode_stub_helper< 40 | Ret, 41 | First, 42 | Second, 43 | Third, 44 | Fourth, 45 | void*, 46 | void*, 47 | Pack... 48 | >( 49 | shell, 50 | first, 51 | second, 52 | third, 53 | fourth, 54 | shell_param, 55 | nullptr, 56 | pack... 57 | ); 58 | } 59 | }; 60 | 61 | template 62 | struct argument_remapper> 63 | { 64 | // 4 or less params 65 | template< 66 | typename Ret, 67 | typename First = void*, 68 | typename Second = void*, 69 | typename Third = void*, 70 | typename Fourth = void* 71 | > 72 | static auto do_call( 73 | const void* shell, 74 | void* shell_param, 75 | First first = First{}, 76 | Second second = Second{}, 77 | Third third = Third{}, 78 | Fourth fourth = Fourth{} 79 | ) -> Ret 80 | { 81 | return shellcode_stub_helper< 82 | Ret, 83 | First, 84 | Second, 85 | Third, 86 | Fourth, 87 | void*, 88 | void* 89 | >( 90 | shell, 91 | first, 92 | second, 93 | third, 94 | fourth, 95 | shell_param, 96 | nullptr 97 | ); 98 | } 99 | }; 100 | } 101 | 102 | 103 | template 104 | static inline auto spoof_call( 105 | const void* trampoline, 106 | Ret(*fn)(Args...), 107 | Args... args 108 | ) -> Ret 109 | { 110 | struct shell_params 111 | { 112 | const void* trampoline; 113 | void* function; 114 | void* rbx; 115 | }; 116 | 117 | shell_params p{ trampoline, reinterpret_cast(fn) }; 118 | using mapper = detail::argument_remapper; 119 | return mapper::template do_call((const void*)&detail::_spoofer_stub, &p, args...); 120 | } -------------------------------------------------------------------------------- /cstrike/core/spoofcall/callstack.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/spoofcall/callstack.cpp -------------------------------------------------------------------------------- /cstrike/core/spoofcall/callstack.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/spoofcall/callstack.h -------------------------------------------------------------------------------- /cstrike/core/spoofcall/callstack.hpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/spoofcall/callstack.hpp -------------------------------------------------------------------------------- /cstrike/core/spoofcall/invoker.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include "Utils.h" 6 | 7 | class RetSpoofInvoker { 8 | private: 9 | void* gadgetAddress{ 0 }; 10 | public: 11 | void init(std::uintptr_t gadgetAddress) noexcept 12 | { 13 | this->gadgetAddress = reinterpret_cast(gadgetAddress); 14 | } 15 | 16 | template 17 | ReturnType invokeFastcall(std::uintptr_t functionAddress, Args&&... args) const noexcept 18 | { 19 | return detail::shellcode_stub_helper::spoof_call(this->gadgetAddress, reinterpret_cast(functionAddress), std::forward(args)...); 20 | } 21 | }; 22 | 23 | inline RetSpoofInvoker invoker; -------------------------------------------------------------------------------- /cstrike/core/stdafx.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/stdafx.h -------------------------------------------------------------------------------- /cstrike/core/variables.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/core/variables.cpp -------------------------------------------------------------------------------- /cstrike/cstrike.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | true 5 | 6 | 7 | C:\Program Files %28x86%29\Steam\steamapps\common\Counter-Strike Global Offensive\game\bin\win64\cs2.exe 8 | true 9 | WindowsLocalDebugger 10 | 11 | 12 | C:\Program Files %28x86%29\Steam\steamapps\common\Counter-Strike Global Offensive\game\bin\win64\cs2.exe 13 | true 14 | WindowsLocalDebugger 15 | 16 | 17 | C:\Program Files %28x86%29\Steam\steamapps\common\Counter-Strike Global Offensive\game\bin\win64\cs2.exe 18 | true 19 | WindowsLocalDebugger 20 | 21 | 22 | C:\Program Files %28x86%29\Steam\steamapps\common\Counter-Strike Global Offensive\game\bin\win64\cs2.exe 23 | true 24 | WindowsLocalDebugger 25 | 26 | -------------------------------------------------------------------------------- /cstrike/features.cpp: -------------------------------------------------------------------------------- 1 | #include "features.h" 2 | 3 | // used: draw callbacks 4 | #include "utilities/draw.h" 5 | // used: notify 6 | #include "utilities/notify.h" 7 | 8 | // used: cheat variables 9 | #include "core/variables.h" 10 | // used: menu 11 | #include "core/menu.h" 12 | 13 | // used: features callbacks 14 | #include "features/visuals.h" 15 | #include "features/misc.h" 16 | #include "features/legit/legit.h" 17 | // used: interfaces 18 | #include "core/interfaces.h" 19 | #include "sdk/interfaces/iengineclient.h" 20 | #include "sdk/interfaces/cgameentitysystem.h" 21 | #include "sdk/datatypes/usercmd.h" 22 | #include "sdk/entity.h" 23 | #include 24 | #include "../cstrike/sdk/interfaces/iinputsystem.h" 25 | #include "../cstrike/utilities/inputsystem.h" 26 | #include "features/visuals/overlay.h" 27 | #include "features/skins/skin_changer.hpp" 28 | 29 | std::vector g_keybinds; 30 | //[181.214.231.239:27042 31 | bool F::Setup() 32 | { 33 | if (!VISUALS::Setup()) 34 | { 35 | L_PRINT(LOG_ERROR) << CS_XOR("failed to setup visuals"); 36 | return false; 37 | } 38 | L_PRINT(LOG_NONE) << L::SetColor(LOG_COLOR_FORE_GREEN | LOG_COLOR_FORE_INTENSITY) << CS_XOR("features VISUALS completed"); 39 | 40 | return true; 41 | } 42 | 43 | void F::OnKeyBindUpdate() { 44 | 45 | if (IPT::GetBindState(C_GET(KeyBind_t, Vars.OverlayKey)) || C_GET(KeyBind_t, Vars.OverlayKey).bEnable) { 46 | const KeyBind_t& overlayKeyBind = C_GET(KeyBind_t, Vars.OverlayKey); 47 | 48 | L_PRINT(LOG_INFO) << CS_XOR("[Keybind] GotBindState | key: ") << 49 | overlayKeyBind.uKey << "| name: " << 50 | overlayKeyBind.szName << "| states "; 51 | 52 | if (overlayKeyBind.nMode == EKeyBindMode::HOLD) { 53 | C_SET(bool, Vars.bVisualOverlay, true); 54 | } 55 | else if (overlayKeyBind.nMode == EKeyBindMode::TOGGLE) { 56 | C_SET(bool, Vars.bVisualOverlay, !C_GET(bool, Vars.bVisualOverlay)); 57 | } 58 | } 59 | } 60 | 61 | bool F::OnDrawObject(void* pAnimatableSceneObjectDesc, void* pDx11, material_data_t* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2) 62 | { 63 | return VISUALS::OnDrawObject(pAnimatableSceneObjectDesc, pDx11, arrMeshDraw, nDataCount, pSceneView, pSceneLayer, pUnk, pUnk2); 64 | } 65 | -------------------------------------------------------------------------------- /cstrike/features.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "common.h" 4 | 5 | class CUserCmd; 6 | class CCSPlayerController; 7 | class material_data_t; 8 | class CCSGOInput; 9 | namespace F 10 | { 11 | bool Setup(); 12 | void OnKeyBindUpdate(); 13 | bool OnDrawObject(void* pAnimatableSceneObjectDesc, void* pDx11, material_data_t* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2); 14 | } 15 | -------------------------------------------------------------------------------- /cstrike/features/antiaim/antiaim.cpp: -------------------------------------------------------------------------------- 1 | #include "antiaim.hpp" 2 | #include 3 | #include 4 | #include "../../core/variables.h" 5 | 6 | void F::ANTIAIM::RunAA(CUserCmd* pCmd) 7 | { 8 | if (!C_GET(bool, Vars.bAntiAim)) 9 | return; 10 | 11 | if (!I::Engine->IsConnected() || !I::Engine->IsInGame()) // Checking if you are connected and in game 12 | return; 13 | 14 | if (!SDK::LocalController || !SDK::LocalController->IsPawnAlive()) // Checking if your spectating and alive 15 | return; 16 | 17 | if (pCmd->m_nButtons.m_nValue & ECommandButtons::IN_USE || pCmd->m_nButtons.m_nValue & ECommandButtons::IN_ATTACK) // Checking if you are not pressing e or attacking 18 | return; 19 | 20 | if (int32_t nMoveType = SDK::LocalController->GetMoveType(); nMoveType == MOVETYPE_NOCLIP || nMoveType == MOVETYPE_LADDER) 21 | return; 22 | 23 | C_CSPlayerPawn* pLocalPawn = I::GameResourceService->pGameEntitySystem->Get(SDK::LocalController->GetPawnHandle()); 24 | 25 | if (pLocalPawn == nullptr) 26 | return; 27 | 28 | if (SDK::LocalController->IsThrowingGrenade(SDK::LocalController->GetPlayerWeapon(SDK::LocalPawn))) 29 | return; 30 | 31 | float flPitch = 0; 32 | float flYaw = 0; 33 | 34 | switch (C_GET(int, Vars.iBaseYawType)) 35 | { 36 | case 0: 37 | break; 38 | case 1: 39 | flYaw += -180.f; // Backwards 40 | break; 41 | case 2: 42 | flYaw += 180.f; // Forwards 43 | break; 44 | default: 45 | break; 46 | } 47 | 48 | switch (C_GET(int, Vars.iPitchType)) 49 | { 50 | case 0: 51 | break; 52 | case 1: // Down 53 | flPitch = 120.f; 54 | break; 55 | case 2: // Up 56 | flPitch = -120.f; 57 | break; 58 | case 3: // Zero 59 | flPitch = 0.f; 60 | break; 61 | default: 62 | break; 63 | } 64 | 65 | pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.x = flPitch; 66 | pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.y += flYaw; 67 | 68 | pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.y = MATH::AngleNormalize(pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.y); 69 | pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.x = MATH::AngleNormalize(pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.x); 70 | pCmd->m_csgoUserCmd.m_pBaseCmd->m_pViewangles->m_angValue.z = 0.f; 71 | } -------------------------------------------------------------------------------- /cstrike/features/antiaim/antiaim.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../sdk/datatypes/qangle.h" 3 | #include "../../sdk/entity.h" 4 | #include "../../sdk/interfaces/cgameentitysystem.h" 5 | #include "../../sdk/interfaces/iengineclient.h" 6 | #include "../../sdk/interfaces/ccsgoinput.h" 7 | #include "../../core/sdk.h" 8 | #include "../../core/interfaces.h" 9 | #include "../../sdk/datatypes/usercmd.h" 10 | 11 | namespace F::ANTIAIM 12 | { 13 | inline QAngle_t angStoredViewBackup{}; 14 | void RunAA(CUserCmd* pCmd); 15 | } -------------------------------------------------------------------------------- /cstrike/features/enginepred/pred.cpp: -------------------------------------------------------------------------------- 1 | #include "pred.h" 2 | #include "../../core/config.h" 3 | #include "../../core/variables.h" 4 | #include "../../sdk/datatypes/usercmd.h" 5 | #include "../../core/sdk.h" 6 | #include "../../sdk/entity.h" 7 | #include "../../sdk/interfaces/iengineclient.h" 8 | #include "../../sdk/interfaces/iglobalvars.h" 9 | #include "../../sdk/interfaces/cgameentitysystem.h" 10 | #include "../../sdk/datatypes/qangle.h" 11 | #include "../../sdk/datatypes/vector.h" 12 | 13 | #include "../cstrike/sdk/interfaces/ccsgoinput.h" 14 | #include "../cstrike/sdk/interfaces/ienginecvar.h" 15 | #include "../lagcomp/lagcomp.h" 16 | #include "../cstrike/sdk/interfaces/events.h" 17 | #include "../penetration/penetration.h" 18 | #include 19 | #include 20 | static float old_current_time = 0.f; 21 | static float old_frame_time = 0.f; 22 | static std::int32_t prediction_seed = 0; 23 | static std::uint32_t predicted_flags = 0; 24 | 25 | void F::PREDICTION::impl::start(CUserCmd* cmd) 26 | { 27 | if (!SDK::LocalController || !SDK::LocalPawn) { 28 | return; 29 | } 30 | auto controller = SDK::LocalController; 31 | if (!controller) 32 | return; 33 | 34 | auto local = SDK::LocalPawn; 35 | if (!local) 36 | return; 37 | 38 | predicted_flags = local->GetFlags(); 39 | 40 | // random_seed 41 | 42 | old_current_time = I::GlobalVars->flCurtime; 43 | old_frame_time = I::GlobalVars->flFrameTime; 44 | 45 | I::GlobalVars->flCurtime = controller->m_nTickBase() * I::GlobalVars->flIntervalPerTick; 46 | I::GlobalVars->flCurtime2 = controller->m_nTickBase() * I::GlobalVars->flIntervalPerTick; 47 | 48 | I::GlobalVars->flFrameTime = I::GlobalVars->flIntervalPerTick; 49 | I::GlobalVars->flFrameTime2 = I::GlobalVars->flIntervalPerTick; 50 | 51 | } 52 | 53 | void F::PREDICTION::impl::end() 54 | { 55 | if (!SDK::LocalController || !SDK::LocalPawn) { 56 | return; 57 | } 58 | auto controller = SDK::LocalController; 59 | if (!controller) 60 | return; 61 | 62 | auto local = SDK::LocalPawn; 63 | if (!local) 64 | return; 65 | 66 | I::GlobalVars->flCurtime = old_current_time; 67 | I::GlobalVars->flCurtime2 = old_current_time; 68 | 69 | I::GlobalVars->flFrameTime = old_current_time; 70 | I::GlobalVars->flFrameTime2 = old_current_time; 71 | } 72 | 73 | std::uint32_t F::PREDICTION::impl::Flags() 74 | { 75 | return predicted_flags; 76 | } -------------------------------------------------------------------------------- /cstrike/features/enginepred/pred.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../common.h" 4 | #include 5 | // used: draw system 6 | #include "../../utilities/draw.h" 7 | #include "../../sdk/datatypes/vector.h" 8 | #include "../../sdk/datatypes/transform.h" 9 | #include "../../sdk/datatypes/qangle.h" 10 | #include "../cstrike/core/config.h" 11 | class CCSPlayerController; 12 | class C_BaseEntity; 13 | class C_CSPlayerPawn; 14 | class CBaseHandle; 15 | class CEntityInstance; 16 | class CUserCmd; 17 | class CBaseUserCmdPB; 18 | class QAngle_t; 19 | class IGameEvent; 20 | class CCSWeaponBaseVData; 21 | namespace F::PREDICTION 22 | { 23 | class impl { 24 | public: 25 | 26 | void start(CUserCmd* cmd); 27 | 28 | void end(); 29 | 30 | std::uint32_t Flags(); 31 | 32 | }; 33 | const auto prediction = std::make_unique(); 34 | } 35 | -------------------------------------------------------------------------------- /cstrike/features/lagcomp/lagcomp.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/features/lagcomp/lagcomp.cpp -------------------------------------------------------------------------------- /cstrike/features/lagcomp/lagcomp.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/features/lagcomp/lagcomp.h -------------------------------------------------------------------------------- /cstrike/features/misc.cpp: -------------------------------------------------------------------------------- 1 | #include "misc.h" 2 | 3 | // used: movement callback 4 | #include "misc/movement.h" 5 | #include "legit/legit.h" 6 | #include "../utilities/log.h" 7 | #include "lagcomp/lagcomp.h" 8 | #include "../cstrike/sdk/datatypes/qangle.h" 9 | #include "../cstrike/sdk/entity.h" 10 | #include "../cstrike/sdk/datatypes/usercmd.h" 11 | #include "enginepred/pred.h" 12 | 13 | #include "../sdk/interfaces/events.h" 14 | #include "rage/rage.h" 15 | 16 | -------------------------------------------------------------------------------- /cstrike/features/misc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | class CUserCmd; 3 | class CCSPlayerController; 4 | class C_CSPlayerPawn; 5 | class QAngle_t; 6 | class CCSGOInput; 7 | namespace F::MISC 8 | { 9 | } -------------------------------------------------------------------------------- /cstrike/features/misc/movement.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class CUserCmd; 4 | class CBaseUserCmdPB; 5 | class CCSGOInputHistoryEntryPB; 6 | class CBasePlayerController; 7 | class CCSPlayerController; 8 | class C_CSPlayerPawn; 9 | class CSubtickMoveStep; 10 | class QAngle_t; 11 | 12 | namespace F::MISC::MOVEMENT 13 | { 14 | 15 | void EdgeBug(CCSPlayerController* controler, C_CSPlayerPawn* localPlayer, CUserCmd* cmd); 16 | 17 | void movment_fix(CUserCmd* pCmd, QAngle_t angle); 18 | 19 | void ProcessMovement(CUserCmd* pCmd, CCSPlayerController* pLocalController, C_CSPlayerPawn* pLocalPawn); 20 | 21 | void BunnyHop(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn); 22 | void AutoStrafe(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, C_CSPlayerPawn* pLocalPawn, int type); 23 | 24 | void MovementCorrection(CBaseUserCmdPB* pUserCmd, CCSGOInputHistoryEntryPB* pInputHistory, const QAngle_t& angDesiredViewPoint); 25 | 26 | // will call MovementCorrection && validate user's angView to avoid untrusted ban 27 | void ValidateUserCommand(CUserCmd* pCmd, CBaseUserCmdPB* pUserCmd, CCSGOInputHistoryEntryPB* pInputHistory); 28 | 29 | } 30 | -------------------------------------------------------------------------------- /cstrike/features/penetration/penetration.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../../common.h" 4 | #include 5 | // used: draw system 6 | #include "../../utilities/draw.h" 7 | #include "../../sdk/datatypes/vector.h" 8 | #include "../../sdk/datatypes/transform.h" 9 | #include "../../sdk/datatypes/qangle.h" 10 | #include "../cstrike/core/config.h" 11 | #include 12 | class C_BaseEntity; 13 | class CCSWeaponBaseVData; 14 | class Vector_t; 15 | class C_CSPlayerPawn; 16 | class CCSPlayerController; 17 | class CBaseHandle; 18 | class CEntityInstance; 19 | class CUserCmd; 20 | class CBaseUserCmdPB; 21 | class QAngle_t; 22 | class IGameEvent; 23 | 24 | namespace F::AUTOWALL { 25 | class c_auto_wall { 26 | public: 27 | struct data_t { 28 | enum e_pos { e_local, e_target }; 29 | data_t() = default; 30 | 31 | CS_INLINE data_t(const Vector_t local_pos, const Vector_t target_pos, 32 | C_BaseEntity* target, 33 | C_BaseEntity* local, 34 | C_CSPlayerPawn* localpawn, C_CSPlayerPawn* targetpawn, 35 | CCSWeaponBaseVData* wpn_data, const bool fire_bullet) noexcept : 36 | m_pos{ local_pos, target_pos }, 37 | m_target(target), 38 | m_local(local), 39 | m_local_pawn(localpawn), 40 | m_target_pawn(targetpawn), 41 | m_wpn_data(wpn_data), 42 | m_can_hit(fire_bullet){} 43 | 44 | 45 | std::array< Vector_t, static_cast(sizeof(e_pos)) > m_pos{ }; 46 | C_BaseEntity* m_target{ }, * m_local{ }; 47 | C_CSPlayerPawn* m_local_pawn{}; 48 | C_CSPlayerPawn* m_target_pawn{}; 49 | CCSWeaponBaseVData* m_wpn_data{ }; 50 | 51 | bool m_can_hit{ }; 52 | float m_dmg{ }; 53 | } m_data; 54 | void pen(data_t& data, const Vector_t local_pos, const Vector_t target_pos, C_BaseEntity* target, C_BaseEntity* local, C_CSPlayerPawn* localpawn, C_CSPlayerPawn* targetpawn, 55 | CCSWeaponBaseVData* wpn_data, float &dmg, bool &valid); 56 | void ScaleDamage(data_t& data, const int hitgroup, C_CSPlayerPawn* entity); 57 | bool FireBullet(data_t& data, float &dmg, bool &valid); 58 | void ScaleDamage2(const int iHitGroup, C_CSPlayerPawn* pCSPlayer, const float flWeaponArmorRatio, const float flWeaponHeadShotMultiplier, float* pflDamageToScale); 59 | public: 60 | [[nodiscard]] CS_INLINE auto get_data(data_t& data) const noexcept { return data; } 61 | }; 62 | 63 | extern std::unique_ptr g_auto_wall; 64 | } -------------------------------------------------------------------------------- /cstrike/features/post_processing.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // WIP 4 | 5 | #define IMGUI_DEFINE_MATH_OPERATORS 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | #include "../../sdk/shaders/build/gaussian_blur.hpp" 16 | 17 | struct VSConstants { 18 | DirectX::XMMATRIX projection; 19 | }; 20 | 21 | namespace PostProcessing { 22 | void setDevice(ID3D11Device* device, ID3D11DeviceContext* deviceContext, 23 | ID3D11RenderTargetView* renderTarget, 24 | IDXGISwapChain* swapChain) noexcept; 25 | void clearBlurTextures() noexcept; 26 | void onDeviceReset() noexcept; 27 | void performFullscreenBlur(ImDrawList* drawList, float alpha) noexcept; 28 | void performBlur(ImDrawList* drawList, const ImVec2& p_min, const ImVec2& p_max, 29 | float alpha) noexcept; 30 | } // namespace PostProcessing 31 | -------------------------------------------------------------------------------- /cstrike/features/rage/rage.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/features/rage/rage.cpp -------------------------------------------------------------------------------- /cstrike/features/skins/ccsinventorymanager.cpp: -------------------------------------------------------------------------------- 1 | #include "ccsinventorymanager.hpp" 2 | 3 | #include "../cstrike/utilities/memory.h" 4 | #include "../cstrike/core/interfaces.h" 5 | #include "../cstrike/core/hooks.h" 6 | CCSInventoryManager* CCSInventoryManager::GetInstance() { 7 | if (!H::fnGetInventoryManager) return nullptr; 8 | return H::fnGetInventoryManager(); 9 | 10 | 11 | } -------------------------------------------------------------------------------- /cstrike/features/skins/ccsinventorymanager.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../cstrike/utilities/memory.h" 4 | class CCSPlayerInventory; 5 | 6 | class CCSInventoryManager { 7 | public: 8 | static CCSInventoryManager* GetInstance(); 9 | 10 | auto EquipItemInLoadout(int iTeam, int iSlot, uint64_t iItemID) { 11 | return MEM::CallVFunc( this, iTeam, iSlot, iItemID); 12 | } 13 | auto GetLocalInventory() { 14 | return MEM::CallVFunc(this); 15 | } 16 | 17 | }; 18 | -------------------------------------------------------------------------------- /cstrike/features/skins/ccsplayerinventory.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | 6 | #include "../cstrike/sdk/entity.h" 7 | #include "../cstrike/sdk/datatypes/utlvector.h" 8 | 9 | 10 | #include "ccsinventorymanager.hpp" 11 | #include 12 | 13 | 14 | class CCSPlayerInventory { 15 | public: 16 | static CCSPlayerInventory* GetInstance(); 17 | 18 | auto SOCreated(SOID_t owner, CSharedObject* pObject, ESOCacheEvent eEvent) { 19 | return MEM::CallVFunc(this, owner, pObject, eEvent); 20 | } 21 | 22 | auto SOUpdated(SOID_t owner, CSharedObject* pObject, ESOCacheEvent eEvent) { 23 | return MEM::CallVFunc(this, owner, pObject, eEvent); 24 | 25 | } 26 | 27 | auto SODestroyed(SOID_t owner, CSharedObject* pObject, ESOCacheEvent eEvent) { 28 | return MEM::CallVFunc(this, owner, pObject, eEvent); 29 | } 30 | 31 | auto GetItemInLoadout(int iClass, int iSlot) { 32 | return MEM::CallVFunc(this, iClass, iSlot); 33 | } 34 | 35 | bool AddEconItem(CEconItem* pItem); 36 | void RemoveEconItem(CEconItem* pItem); 37 | std::pair GetHighestIDs(); 38 | C_EconItemView* GetItemViewForItem(uint64_t itemID); 39 | CEconItem* GetSOCDataForItem(uint64_t itemID); 40 | 41 | auto GetOwner() { 42 | return *reinterpret_cast((uintptr_t)(this) + 0x10); 43 | } 44 | 45 | auto& GetItemVector() { 46 | return *reinterpret_cast*>( 47 | (uintptr_t)(this) + 0x20); 48 | } 49 | }; 50 | -------------------------------------------------------------------------------- /cstrike/features/skins/skin_changer.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class IGameEvent; 4 | class CEconItem; 5 | class C_BaseModelEntity; 6 | class CCSPlayerInventory; 7 | class C_CSPlayerPawn; 8 | class CEconItemDefinition; 9 | class C_BaseViewModel; 10 | class C_EconItemView; 11 | 12 | namespace skin_changer { 13 | 14 | enum material_magic_number : uint32_t 15 | { 16 | material_magic_number__gloves = 0xf143b82a, 17 | material_magic_number__unknown1 = 0x1b52829c, 18 | material_magic_number__unknown2 = 0xa6ebe9b9, 19 | material_magic_number__unknown3 = 0x423b2ed4, 20 | material_magic_number__unknown4 = 0xc8d7255e 21 | }; 22 | 23 | struct material_record 24 | { 25 | uint32_t ui32_unknwonstatic; 26 | material_magic_number identifer; 27 | uint32_t ui32_handle; 28 | uint32_t ui32_type_index; 29 | }; 30 | 31 | void OnFrameStageNotify(int frameStage); 32 | void OnGlove(CCSPlayerInventory* pInventory, C_CSPlayerPawn* pLocalPawn, C_BaseViewModel* pViewModel, C_EconItemView* GlovesItem, CEconItemDefinition* GlovesDefinition) ; 33 | void OnPreFireEvent(IGameEvent* pEvent); 34 | void OnRoundReset(IGameEvent* pEvent); 35 | 36 | void OnEquipItemInLoadout(int team, int slot, uint64_t itemID); 37 | void OnSetModel(C_BaseModelEntity* pEntity, const char*& model); 38 | 39 | void AddEconItemToList(CEconItem* pItem); 40 | void Shutdown(); 41 | } // namespace skin_changer 42 | -------------------------------------------------------------------------------- /cstrike/features/visuals.cpp: -------------------------------------------------------------------------------- 1 | #include "visuals.h" 2 | 3 | // used: source sdk 4 | #include "../sdk/interfaces/iengineclient.h" 5 | #include "../sdk/entity.h" 6 | 7 | // used: overlay 8 | #include "visuals/overlay.h" 9 | #include "visuals/chams.h" 10 | 11 | #include "../core/sdk.h" 12 | 13 | using namespace F; 14 | 15 | bool F::VISUALS::Setup() 16 | { 17 | if (!ams::chams->initialize()) 18 | { 19 | L_PRINT(LOG_ERROR) << CS_XOR("failed to initialize DrawObject chams | swapping to K3V"); 20 | return true; 21 | } 22 | L_PRINT(LOG_NONE) << L::SetColor(LOG_COLOR_FORE_GREEN | LOG_COLOR_FORE_INTENSITY) << CS_XOR("chams initialization completed"); 23 | 24 | 25 | return true; 26 | } 27 | 28 | bool F::VISUALS::OnDrawObject(void* pAnimatableSceneObjectDesc, void* pDx11, material_data_t* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2) 29 | { 30 | return ams::chams->draw_object(pAnimatableSceneObjectDesc, pDx11, arrMeshDraw, nDataCount, pSceneView, pSceneLayer, pUnk, pUnk2); 31 | } 32 | -------------------------------------------------------------------------------- /cstrike/features/visuals.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class material_data_t; 4 | 5 | namespace F::VISUALS 6 | { 7 | bool Setup(); 8 | void OnFrame(const int nStage); 9 | bool OnDrawObject(void* pAnimatableSceneObjectDesc, void* pDx11, material_data_t* arrMeshDraw, int nDataCount, void* pSceneView, void* pSceneLayer, void* pUnk, void* pUnk2); 10 | } 11 | -------------------------------------------------------------------------------- /cstrike/features/visuals/chams.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #pragma once 4 | 5 | #include "../../common.h" 6 | #include 7 | #include "../cstrike/sdk/datatypes/stronghandle.hpp" 8 | #pragma once 9 | class material_data_t; 10 | class material2_t; 11 | namespace ams { 12 | class chams_t { 13 | public: 14 | bool initialize(); 15 | void destroy(); 16 | public: 17 | bool draw_object(void* animatable_object, void* dx11, material_data_t* arr_material_data, int data_count, 18 | void* scene_view, void* scene_layer, void* unk1, void* unk2); 19 | 20 | bool override_material(void* animatable_object, void* dx11, material_data_t* arr_material_data, int data_count, 21 | void* scene_view, void* scene_layer, void* unk1, void* unk2); 22 | public: 23 | material2_t* CreateMaterial(const char* szName, const char* szMaterialVMAT, const char* szShaderType, bool bBlendMode, bool bTranslucent, bool bDisableZBuffering); 24 | 25 | material2_t* create_material(const char* m_name, const char* material_vmat, const char* shader_type, bool blend_mode, 26 | bool transfluscent, bool disable_buffering); 27 | private: 28 | bool m_initialized = false; 29 | }; 30 | const auto chams = std::make_unique(); 31 | 32 | 33 | } -------------------------------------------------------------------------------- /cstrike/icons/bayonet.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/bomb.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/cz75a.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/deagle.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/elite.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/fiveseven.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/flashbang.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /cstrike/icons/flashed_kill.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 6 | 15 | 16 | 17 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /cstrike/icons/glock.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/hegrenade.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /cstrike/icons/hkp2000.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/icon_defuse_default.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/iconscs2.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/icons/iconscs2.ttf -------------------------------------------------------------------------------- /cstrike/icons/incgrenade0.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_bayonet.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_css.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_falchion.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_flip.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_gut.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_gypsy_jackknife.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_outdoor.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_skeleton.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_stiletto.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_t.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_ursus.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/knife_widowmaker.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/molotov.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/noscope.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | 6 | 15 | 16 | 17 | 18 | 19 | 20 | 23 | 24 | 25 | 26 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /cstrike/icons/obs_icons.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/icons/obs_icons.ttf -------------------------------------------------------------------------------- /cstrike/icons/out.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/p250.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/sawedoff.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/smokegrenade.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /cstrike/icons/taser.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/usp_silencer.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/icons/usp_silencer_off.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /cstrike/multidrop.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #include "../../Utils/InputSys.hpp" 5 | 6 | /* Prototypes */ 7 | struct MultiItem_t { 8 | std::string name; 9 | bool* value; 10 | }; 11 | 12 | /* Context structs */ 13 | struct DropdownInfo_t { 14 | size_t HashedID; 15 | 16 | std::map uScroll; 17 | 18 | std::vector Elements; 19 | int* Option; 20 | 21 | int MaxItems; 22 | 23 | bool out_anim; 24 | bool DraggingScroll; 25 | 26 | float Size = 0.f; 27 | Vector2D Pos = { 0, 0 }; 28 | }; 29 | 30 | struct MultiDropdownInfo_t { 31 | size_t HashedID; 32 | 33 | std::map uScroll; 34 | 35 | std::vector Elements; 36 | 37 | int MaxItems; 38 | bool DraggingScroll; 39 | 40 | float Size = 0.f; 41 | Vector2D Pos = { 0, 0 }; 42 | }; -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/K3V.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "K3V.h" 3 | #include "../../utilities/memory.h" 4 | // sig 1:48 8B C4 55 48 8D A8 08 FD 5 | /* 6 | KeyValues3* KeyValues3::set_type(kv_basic_type a1, kv_basic_type a2) 7 | { 8 | using fnTypeData = KeyValues3*(__fastcall*)(uint8_t, uint8_t); 9 | static auto setType = *reinterpret_cast(MEM::FindPattern(CLIENT_DLL, CS_XOR("48 8B C4 55 48 8D A8 08 FD"))); 10 | 11 | #ifdef CS_PARANOID 12 | CS_ASSERT(setType != nullptr); 13 | #endif 14 | 15 | return setType(a1, a2); 16 | } 17 | 18 | //48 89 5C 24 08 48 89 74 24 10 57 48 81 EC E0 00 00 00 48 19 | KeyValues3* KeyValues3::create_object(const char* name, bool unk1) 20 | { 21 | 22 | // Assuming that MEM::FindPattern returns the function address correctly 23 | using CreateObjectFn = KeyValues3*(__fastcall*)(const char*, bool); 24 | static CreateObjectFn createObjectFn = *reinterpret_cast(MEM::FindPattern(CLIENT_DLL, CS_XOR("48 89 5C 24 08 48 89 74 24 10 57 48 81 EC E0 00 00 00 48"))); 25 | CS_ASSERT(createObjectFn != nullptr); 26 | 27 | return createObjectFn(name, unk1); 28 | } 29 | */ 30 | /* 31 | //client.dll 48 89 5C 24 ?? 48 89 6C 24 ?? 56 57 41 54 41 56 41 57 48 83 EC 30 0F B6 01 45 0F B6 F9 8B 2A 4D 8B E0 4C 8B 72 08 48 8B F9 32 | void KeyValues3::set_data(const char* name, const char* value, kv_field_type_t field) 33 | { 34 | using fnSetData = void(__fastcall*)(void*, const char*, const char*, kv_field_type_t); 35 | static auto setData = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, CS_XOR("48 89 5C 24 ?? 48 89 6C 24 ?? 56 57 41 54 41 56 41 57 48 83 EC 30 0F B6 01 45 0F B6 F9 8B 2A 4D 8B E0 4C 8B 72 08 48 8B F9"))); 36 | 37 | #ifdef CS_PARANOID 38 | CS_ASSERT(setData != nullptr); 39 | #endif 40 | 41 | setData(this, name, value, field); 42 | } 43 | 44 | void KeyValues3::set_data(const char* name, uint32_t color) 45 | { 46 | using fnSetData = void(__fastcall*)(void*, const char*, uint32_t); 47 | static auto setData = reinterpret_cast(MEM::FindPattern(PARTICLES_DLL, CS_XOR("E8 ?? ?? ?? ?? 49 C1 E5 21"))); 48 | 49 | #ifdef CS_PARANOID 50 | CS_ASSERT(setData != nullptr); 51 | #endif 52 | 53 | setData(this, name, color); 54 | } 55 | 56 | void KeyValues3::set_data(const char* name, int value) 57 | { 58 | using fnSetData = void(__fastcall*)(void*, const char*, int); 59 | static auto setData = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, CS_XOR(""))); 60 | 61 | #ifdef CS_PARANOID 62 | CS_ASSERT(setData != nullptr); 63 | #endif 64 | 65 | setData(this, name, value); 66 | } 67 | 68 | bool KeyValues3::load_from_buffer() 69 | { 70 | return false; 71 | } 72 | */ 73 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/K3V.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include "../cstrike/common.h" 6 | #include 7 | class CKeyValues3 8 | { 9 | public: 10 | uint64_t uKey; 11 | void* pValue; 12 | 13 | std::byte pad[0x8]; 14 | }; 15 | 16 | struct KV3IVD_t 17 | { 18 | const char* szName; 19 | uint64_t unk0; 20 | uint64_t unk1; 21 | }; 22 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/cstronghandle.hpp: -------------------------------------------------------------------------------- 1 | struct ResourceBinding_t { 2 | void* data; 3 | }; 4 | 5 | template 6 | class CStrongHandle { 7 | public: 8 | explicit operator T* () const { 9 | return is_valid() ? reinterpret_cast(binding_->data) : nullptr; 10 | } 11 | 12 | T* operator->() const { 13 | return is_valid() ? reinterpret_cast(binding_->data) : nullptr; 14 | } 15 | 16 | 17 | [[nodiscard]] bool is_valid() const { return binding_->data != nullptr; } 18 | 19 | private: 20 | const ResourceBinding_t* binding_; 21 | }; 22 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/matrix.cpp: -------------------------------------------------------------------------------- 1 | #include "matrix.h" 2 | 3 | #include "qangle.h" 4 | 5 | // used: m_rad2deg 6 | #include "../../utilities/math.h" 7 | 8 | [[nodiscard]] QAngle_t Matrix3x4_t::ToAngles() const 9 | { 10 | // extract the basis vectors from the matrix. since we only need the z component of the up vector, we don't get x and y 11 | const Vector_t vecForward = this->GetForward(); 12 | const Vector_t vecLeft = this->GetLeft(); 13 | const float flUpZ = this->arrData[2][2]; 14 | 15 | const float flLength2D = vecForward.Length2D(); 16 | const float flPitch = M_RAD2DEG(std::atan2f(-vecForward.z, flLength2D)); 17 | 18 | // check is enough here to get angles 19 | if (flLength2D > 0.001f) 20 | return { flPitch, M_RAD2DEG(std::atan2f(vecForward.y, vecForward.x)), M_RAD2DEG(std::atan2f(vecLeft.z, flUpZ)) }; 21 | 22 | // forward is mostly Z, gimbal lock 23 | // assume no roll in this case as one degree of freedom has been lost (i.e. yaw equals roll) 24 | return { flPitch, M_RAD2DEG(std::atan2f(-vecLeft.x, vecLeft.y)), 0.0f }; 25 | } -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/qangle.cpp: -------------------------------------------------------------------------------- 1 | #include "qangle.h" 2 | 3 | // used: [d3d] xmscalarsincos 4 | #include 5 | 6 | #include "matrix.h" 7 | 8 | // used: m_deg2rad 9 | #include "../../utilities/math.h" 10 | 11 | void QAngle_t::ToDirections(Vector_t* pvecForward, Vector_t* pvecRight, Vector_t* pvecUp) const 12 | { 13 | float flPitchSin, flPitchCos, flYawSin, flYawCos, flRollSin, flRollCos; 14 | DirectX::XMScalarSinCos(&flPitchSin, &flPitchCos, M_DEG2RAD(this->x)); 15 | DirectX::XMScalarSinCos(&flYawSin, &flYawCos, M_DEG2RAD(this->y)); 16 | DirectX::XMScalarSinCos(&flRollSin, &flRollCos, M_DEG2RAD(this->z)); 17 | 18 | if (pvecForward != nullptr) 19 | { 20 | pvecForward->x = flPitchCos * flYawCos; 21 | pvecForward->y = flPitchCos * flYawSin; 22 | pvecForward->z = -flPitchSin; 23 | } 24 | 25 | if (pvecRight != nullptr) 26 | { 27 | pvecRight->x = (-flRollSin * flPitchSin * flYawCos) + (-flRollCos * -flYawSin); 28 | pvecRight->y = (-flRollSin * flPitchSin * flYawSin) + (-flRollCos * flYawCos); 29 | pvecRight->z = (-flRollSin * flPitchCos); 30 | } 31 | 32 | if (pvecUp != nullptr) 33 | { 34 | pvecUp->x = (flRollCos * flPitchSin * flYawCos) + (-flRollSin * -flYawSin); 35 | pvecUp->y = (flRollCos * flPitchSin * flYawSin) + (-flRollSin * flYawCos); 36 | pvecUp->z = (flRollCos * flPitchCos); 37 | } 38 | } 39 | 40 | Matrix3x4_t QAngle_t::ToMatrix(const Vector_t& vecOrigin) const 41 | { 42 | float flPitchSin, flPitchCos, flYawSin, flYawCos, flRollSin, flRollCos; 43 | DirectX::XMScalarSinCos(&flPitchSin, &flPitchCos, M_DEG2RAD(this->x)); 44 | DirectX::XMScalarSinCos(&flYawSin, &flYawCos, M_DEG2RAD(this->y)); 45 | DirectX::XMScalarSinCos(&flRollSin, &flRollCos, M_DEG2RAD(this->z)); 46 | 47 | return { 48 | (flPitchCos * flYawCos), (flRollSin * flPitchSin * flYawCos + flRollCos * -flYawSin), (flRollCos * flPitchSin * flYawCos + -flRollSin * -flYawSin), vecOrigin.x, 49 | (flPitchCos * flYawSin), (flRollSin * flPitchSin * flYawSin + flRollCos * flYawCos), (flRollCos * flPitchSin * flYawSin + -flRollSin * flYawCos), vecOrigin.y, 50 | (-flPitchSin), (flRollSin * flPitchCos), (flRollCos * flPitchCos), vecOrigin.z 51 | }; 52 | } -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/quaternion.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | struct Quaternion_t 4 | { 5 | constexpr Quaternion_t(const float x = 0.0f, const float y = 0.0f, const float z = 0.0f, const float w = 0.0f) : 6 | x(x), y(y), z(z), w(w) { } 7 | 8 | [[nodiscard]] bool IsValid() const 9 | { 10 | return (std::isfinite(x) && std::isfinite(y) && std::isfinite(z) && std::isfinite(w)); 11 | } 12 | 13 | /// @param[in] vecOrigin [optional] translation for converted matrix 14 | /// @returns: matrix converted from quaternion 15 | [[nodiscard]] Matrix3x4_t ToMatrix(const Vector_t& vecOrigin = {}) const 16 | { 17 | CS_ASSERT(this->IsValid()); 18 | 19 | Matrix3x4_t matOut; 20 | 21 | #ifdef _DEBUG // precalculate common multiplications 22 | const float x2 = this->x + this->x, y2 = this->y + this->y, z2 = this->z + this->z; 23 | const float xx = this->x * x2, xy = this->x * y2, xz = this->x * z2; 24 | const float yy = this->y * y2, yz = this->y * z2; 25 | const float zz = this->z * z2; 26 | const float wx = this->w * x2, wy = this->w * y2, wz = this->w * z2; 27 | 28 | matOut[0][0] = 1.0f - (yy + zz); 29 | matOut[1][0] = xy + wz; 30 | matOut[2][0] = xz - wy; 31 | 32 | matOut[0][1] = xy - wz; 33 | matOut[1][1] = 1.0f - (xx + zz); 34 | matOut[2][1] = yz + wx; 35 | 36 | matOut[0][2] = xz + wy; 37 | matOut[1][2] = yz - wx; 38 | matOut[2][2] = 1.0f - (xx + yy); 39 | #else // let the compiler optimize calculations itself 40 | matOut[0][0] = 1.0f - 2.0f * this->y * this->y - 2.0f * this->z * this->z; 41 | matOut[1][0] = 2.0f * this->x * this->y + 2.0f * this->w * this->z; 42 | matOut[2][0] = 2.0f * this->x * this->z - 2.0f * this->w * this->y; 43 | 44 | matOut[0][1] = 2.0f * this->x * this->y - 2.0f * this->w * this->z; 45 | matOut[1][1] = 1.0f - 2.0f * this->x * this->x - 2.0f * this->z * this->z; 46 | matOut[2][1] = 2.0f * this->y * this->z + 2.0f * this->w * this->x; 47 | 48 | matOut[0][2] = 2.0f * this->x * this->z + 2.0f * this->w * this->y; 49 | matOut[1][2] = 2.0f * this->y * this->z - 2.0f * this->w * this->x; 50 | matOut[2][2] = 1.0f - 2.0f * this->x * this->x - 2.0f * this->y * this->y; 51 | #endif 52 | 53 | matOut[0][3] = vecOrigin.x; 54 | matOut[1][3] = vecOrigin.y; 55 | matOut[2][3] = vecOrigin.z; 56 | return matOut; 57 | } 58 | 59 | float x, y, z, w; 60 | }; 61 | 62 | struct alignas(16) QuaternionAligned_t : Quaternion_t 63 | { 64 | QuaternionAligned_t& operator=(const Quaternion_t& quatOther) 65 | { 66 | this->x = quatOther.x; 67 | this->y = quatOther.y; 68 | this->z = quatOther.z; 69 | this->w = quatOther.w; 70 | return *this; 71 | } 72 | }; 73 | 74 | static_assert(alignof(QuaternionAligned_t) == 16); -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/repfieldcontainer.h: -------------------------------------------------------------------------------- 1 | #pragma once -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/resourcebinding_t.hpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include 4 | #include 5 | 6 | #include "utlstring.h" 7 | #include "cinterlockedint.hpp" 8 | 9 | enum EResourceBindingFlags 10 | { 11 | RESOURCE_BINDING_CACHED = 0x1, 12 | RESOURCE_BINDING_ERROR = 0x2, 13 | RESOURCE_BINDING_PERMANENT = 0x4, 14 | RESOURCE_BINDING_ANONYMOUS = 0x8, 15 | }; 16 | 17 | struct ResourceBindingBase_t 18 | { 19 | void* pData = nullptr; 20 | CUtlString* pResourceName = nullptr; 21 | std::uint32_t uFlags = 0; 22 | std::uint8_t uResourceType = -1; 23 | CInterlockedIntT< std::uint32_t > uRefCount = 0; 24 | }; 25 | 26 | template< typename tResource > 27 | struct ResourceBinding_t 28 | : public ResourceBindingBase_t 29 | { 30 | template< class tValue > 31 | friend class CStrongHandle; 32 | 33 | template< class tValue > 34 | friend int ResourceAddRef( const ResourceBinding_t< tValue >* pResource ) noexcept; 35 | 36 | template< class tValue > 37 | friend int ResourceRelease( const ResourceBinding_t< tValue >* pResource ) noexcept; 38 | }; 39 | 40 | template< class tValue > 41 | int ResourceAddRef( const ResourceBinding_t< tValue >* pResource ) noexcept 42 | { 43 | return ++pResource->uRefCount; 44 | } 45 | 46 | template< class tValue > 47 | int ResourceRelease( const ResourceBinding_t< tValue >* pResource ) noexcept 48 | { 49 | return --pResource->uRefCount; 50 | } 51 | 52 | using ResourceHandle_t = ResourceBindingBase_t*; 53 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/resourceutils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: callvfunc 4 | #include "../../utilities/memory.h" 5 | 6 | struct ResourceBinding_t; 7 | 8 | class IResourceSystem 9 | { 10 | public: 11 | void* QueryInterface(const char* szInterfaceName) 12 | { 13 | return MEM::CallVFunc(this, szInterfaceName); 14 | } 15 | }; 16 | 17 | class CResourceHandleUtils 18 | { 19 | public: 20 | void DeleteResource(const ResourceBinding_t* pBinding) 21 | { 22 | MEM::CallVFunc(this, pBinding); 23 | } 24 | }; 25 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/stronghandle.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | struct Resource_t 4 | { 5 | void* pData; 6 | }; 7 | 8 | template 9 | class stronghandle 10 | { 11 | public: 12 | operator T* () const 13 | { 14 | if (pBinding == nullptr) 15 | return nullptr; 16 | 17 | return static_cast(pBinding->pData); 18 | } 19 | 20 | T* operator->() const 21 | { 22 | if (pBinding == nullptr) 23 | return nullptr; 24 | 25 | return static_cast(pBinding->pData); 26 | } 27 | 28 | const Resource_t* pBinding; 29 | }; 30 | 31 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/transform.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: matResult 4 | #include "matrix.h" 5 | // used: quaternion 6 | #include "quaternion.h" 7 | 8 | class CTransform 9 | { 10 | public: 11 | VectorAligned_t vecPosition; 12 | QuaternionAligned_t quatOrientation; 13 | }; 14 | 15 | static_assert(alignof(CTransform) == 16); 16 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/utlmap.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "utlrbtree.h" 3 | #include 4 | 5 | // @source: master/public/tier1/utlmap.h 6 | template 7 | class CUtlMap { 8 | public: 9 | struct Node_t { 10 | int m_left; 11 | int m_right; 12 | int m_parent; 13 | int m_tag; 14 | K m_key; 15 | V m_value; 16 | }; 17 | 18 | auto begin() const { return m_data; } 19 | auto end() const { return m_data + m_size; } 20 | 21 | std::optional FindByKey(K key) const { 22 | int current = m_root; 23 | while (current != -1) { 24 | const Node_t& element = m_data[current]; 25 | if (element.m_key < key) 26 | current = element.m_right; 27 | else if (element.m_key > key) 28 | current = element.m_left; 29 | else 30 | return element.m_value; 31 | } 32 | return {}; 33 | } 34 | 35 | char pad0[0x8]; // no idea 36 | Node_t* m_data; 37 | char pad1[0x8]; // no idea 38 | int m_root; 39 | int m_size; 40 | char pad2[0x8]; // no idea 41 | }; 42 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/utlstring.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "utlmemory.h" 3 | 4 | class CUtlBinaryBlock 5 | { 6 | public: 7 | CUtlBinaryBlock(const int nInitialGrowSize = 0, const int nInitialSize = 0) : 8 | memory(nInitialGrowSize, nInitialSize), nLength(0) { } 9 | 10 | CUtlMemory memory; 11 | int nLength; 12 | }; 13 | 14 | class CUtlString 15 | { 16 | public: 17 | CUtlString() { } 18 | 19 | [[nodiscard]] const char* Get() const 20 | { 21 | if (storage.nLength == 0) 22 | return ""; 23 | 24 | return reinterpret_cast(storage.memory.Base()); 25 | } 26 | 27 | [[nodiscard]] int Length() const 28 | { 29 | return storage.nLength; 30 | } 31 | 32 | private: 33 | CUtlBinaryBlock storage; 34 | }; 35 | 36 | template 37 | class CUtlConstStringBase 38 | { 39 | public: 40 | CUtlConstStringBase() : 41 | pString(nullptr) { } 42 | 43 | [[nodiscard]] const T* Get() const 44 | { 45 | return (pString != nullptr ? pString : static_cast("")); 46 | } 47 | 48 | [[nodiscard]] operator const T*() const 49 | { 50 | return (pString != nullptr ? pString : static_cast("")); 51 | } 52 | 53 | [[nodiscard]] bool Empty() const 54 | { 55 | return (pString == nullptr); 56 | } 57 | 58 | protected: 59 | const T* pString; 60 | }; 61 | 62 | using CUtlConstString = CUtlConstStringBase; 63 | using CUtlConstWideString = CUtlConstStringBase; -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/utlstringtoken.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "utlmemory.h" 3 | 4 | // used: memorymove 5 | #include "../../utilities/fnv1a.h" 6 | 7 | #define STRINGTOKEN_MURMURHASH_SEED 0x31415926 8 | 9 | #pragma pack(push, 8) 10 | class CUtlStringToken 11 | { 12 | public: 13 | explicit CUtlStringToken(const char* szKeyName) 14 | { 15 | uHashCode = FNV1A::Hash(szKeyName, STRINGTOKEN_MURMURHASH_SEED); 16 | szDebugName = szKeyName; 17 | } 18 | 19 | constexpr CUtlStringToken(const FNV1A_t uHashCode, const char* szKeyName) : 20 | uHashCode(uHashCode), szDebugName(szKeyName) { } 21 | 22 | CS_INLINE bool operator==(const CUtlStringToken& other) const 23 | { 24 | return (other.uHashCode == uHashCode); 25 | } 26 | 27 | CS_INLINE bool operator!=(const CUtlStringToken& other) const 28 | { 29 | return (other.uHashCode != uHashCode); 30 | } 31 | 32 | CS_INLINE bool operator<(const CUtlStringToken& other) const 33 | { 34 | return (uHashCode < other.uHashCode); 35 | } 36 | 37 | public: 38 | FNV1A_t uHashCode = 0U; // 0x00 39 | const char* szDebugName = nullptr; // 0x08 // @Todo: for some reason retards keep this even for non-debug builds, it can be changed later 40 | }; 41 | #pragma pack(pop) 42 | 43 | // helper to create a string token at compile-time 44 | CS_INLINE consteval CUtlStringToken MakeStringToken(const char* szKeyName) 45 | { 46 | return { FNV1A::HashConst(szKeyName, STRINGTOKEN_MURMURHASH_SEED), szKeyName }; 47 | } 48 | -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/vector.cpp: -------------------------------------------------------------------------------- 1 | #include "vector.h" 2 | 3 | #include "matrix.h" 4 | #include "qangle.h" 5 | 6 | // used: m_rad2deg 7 | #include "../../utilities/math.h" 8 | 9 | [[nodiscard]] Vector_t Vector_t::Transform(const Matrix3x4_t& matTransform) const 10 | { 11 | return { 12 | this->DotProduct(matTransform[0]) + matTransform[0][3], 13 | this->DotProduct(matTransform[1]) + matTransform[1][3], 14 | this->DotProduct(matTransform[2]) + matTransform[2][3] 15 | }; 16 | } 17 | [[nodiscard]] QAngle_t Vector_t::ToEulerAngles(Vector_t* pseudoup /*= nullptr*/) { 18 | auto pitch = 0.0f; 19 | auto yaw = 0.0f; 20 | auto roll = 0.0f; 21 | 22 | auto length = this->ToVector2D().Length(); 23 | 24 | if (pseudoup) { 25 | auto left = pseudoup->CrossProduct(*this); 26 | 27 | left.Normalizes(); 28 | 29 | pitch = ToDegrees(std::atan2(-this->z, length)); 30 | 31 | if (pitch < 0.0f) 32 | pitch += 360.0f; 33 | 34 | if (length > 0.001f) { 35 | yaw = ToDegrees(std::atan2(this->y, this->x)); 36 | 37 | if (yaw < 0.0f) 38 | yaw += 360.0f; 39 | 40 | auto up_z = (this->x * left.y) - (this->y * left.x); 41 | 42 | roll = ToDegrees(std::atan2(left.z, up_z)); 43 | 44 | if (roll < 0.0f) 45 | roll += 360.0f; 46 | } 47 | else { 48 | yaw = ToDegrees(std::atan2(-left.x, left.y)); 49 | 50 | if (yaw < 0.0f) 51 | yaw += 360.0f; 52 | } 53 | } 54 | else { 55 | if (this->x == 0.0f && this->y == 0.0f) { 56 | if (this->z > 0.0f) 57 | pitch = 270.0f; 58 | else 59 | pitch = 90.0f; 60 | } 61 | else { 62 | pitch = ToDegrees(std::atan2(-this->z, length)); 63 | 64 | if (pitch < 0.0f) 65 | pitch += 360.0f; 66 | 67 | yaw = ToDegrees(std::atan2(this->y, this->x)); 68 | 69 | if (yaw < 0.0f) 70 | yaw += 360.0f; 71 | } 72 | } 73 | 74 | return { pitch, yaw, roll }; 75 | } 76 | 77 | [[nodiscard]] QAngle_t Vector_t::ToAngles() const 78 | { 79 | float flPitch, flYaw; 80 | if (this->x == 0.0f && this->y == 0.0f) 81 | { 82 | flPitch = (this->z > 0.0f) ? 270.f : 90.f; 83 | flYaw = 0.0f; 84 | } 85 | else 86 | { 87 | flPitch = M_RAD2DEG(std::atan2f(-this->z, this->Length2D())); 88 | 89 | if (flPitch < 0.f) 90 | flPitch += 360.f; 91 | 92 | flYaw = M_RAD2DEG(std::atan2f(this->y, this->x)); 93 | 94 | if (flYaw < 0.f) 95 | flYaw += 360.f; 96 | } 97 | 98 | return { flPitch, flYaw, 0.0f }; 99 | } 100 | 101 | [[nodiscard]] Matrix3x4_t Vector_t::ToMatrix() const 102 | { 103 | Vector_t vecRight = {}, vecUp = {}; 104 | this->ToDirections(&vecRight, &vecUp); 105 | 106 | Matrix3x4a_t matOutput = {}; 107 | matOutput.SetForward(*this); 108 | matOutput.SetLeft(-vecRight); 109 | matOutput.SetUp(vecUp); 110 | return matOutput; 111 | } -------------------------------------------------------------------------------- /cstrike/sdk/datatypes/viewsetup.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: mem_pad 4 | #include "../../utilities/memory.h" 5 | 6 | // used: vector_t 7 | #include "vector.h" 8 | // used: qangle_t 9 | #include "qangle.h" 10 | 11 | class CViewSetup 12 | { 13 | public: 14 | MEM_PAD(0x490); 15 | float flOrthoLeft; // 0x0494 16 | float flOrthoTop; // 0x0498 17 | float flOrthoRight; // 0x049C 18 | float flOrthoBottom; // 0x04A0 19 | MEM_PAD(0x38); 20 | float flFov; // 0x04D8 21 | float flFovViewmodel; // 0x04DC 22 | Vector_t vecOrigin; // 0x04E0 23 | MEM_PAD(0xC); // 0x04EC 24 | QAngle_t angView; // 0x04F8 25 | MEM_PAD(0x14); // 0x0504 26 | float flAspectRatio; // 0x0518 27 | }; -------------------------------------------------------------------------------- /cstrike/sdk/entity_handle.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/sdk/entity_handle.cpp -------------------------------------------------------------------------------- /cstrike/sdk/entity_handle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../common.h" 4 | 5 | #define INVALID_EHANDLE_INDEX 0xFFFFFFFF 6 | #define ENT_ENTRY_MASK 0x7FFF 7 | #define NUM_SERIAL_NUM_SHIFT_BITS 15 8 | // @source: https://developer.valvesoftware.com/wiki/Entity_limit#Source_2_limits 9 | #define ENT_MAX_NETWORKED_ENTRY 16384 10 | 11 | 12 | class CBaseHandle 13 | { 14 | public: 15 | CBaseHandle() noexcept : 16 | nIndex(INVALID_EHANDLE_INDEX) { } 17 | 18 | CBaseHandle(const int nEntry, const int nSerial) noexcept 19 | { 20 | CS_ASSERT(nEntry >= 0 && (nEntry & ENT_ENTRY_MASK) == nEntry); 21 | CS_ASSERT(nSerial >= 0 && nSerial < (1 << NUM_SERIAL_NUM_SHIFT_BITS)); 22 | 23 | nIndex = nEntry | (nSerial << NUM_SERIAL_NUM_SHIFT_BITS); 24 | } 25 | 26 | bool operator!=(const CBaseHandle& other) const noexcept 27 | { 28 | return nIndex != other.nIndex; 29 | } 30 | 31 | bool operator==(const CBaseHandle& other) const noexcept 32 | { 33 | return nIndex == other.nIndex; 34 | } 35 | 36 | bool operator<(const CBaseHandle& other) const noexcept 37 | { 38 | return nIndex < other.nIndex; 39 | } 40 | 41 | [[nodiscard]] bool IsValid() const noexcept 42 | { 43 | return nIndex != INVALID_EHANDLE_INDEX; 44 | } 45 | 46 | [[nodiscard]] int GetEntryIndex() const noexcept 47 | { 48 | return static_cast(nIndex & ENT_ENTRY_MASK); 49 | } 50 | 51 | [[nodiscard]] int GetSerialNumber() const noexcept 52 | { 53 | return static_cast(nIndex >> NUM_SERIAL_NUM_SHIFT_BITS); 54 | } 55 | 56 | private: 57 | std::uint32_t nIndex; 58 | 59 | }; 60 | -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/ccsgoinput.cpp: -------------------------------------------------------------------------------- 1 | #include "ccsgoinput.h" 2 | #include "../datatypes/usercmd.h" 3 | #include "../../utilities/memory.h" 4 | 5 | CSubtickMoveStep* CBaseUserCmdPB::AddSubTickMove() 6 | { 7 | if (m_subtickMovesField && m_subtickMovesField.size() < m_subtickMovesField.max_size()) 8 | return m_subtickMovesField[m_subtickMovesField.size()++]; 9 | 10 | static auto sub_258D30 = MEM::FindPattern(CLIENT_DLL, CS_XOR("E8 ? ? ? ? 48 8B D0 48 8D 4B ? E8 ? ? ? ? 48 8B D0") + 0x1); 11 | 12 | CSubtickMoveStep* subtick = reinterpret_cast(sub_258D30)(m_subtickMovesField.unk_field()); 13 | 14 | m_subtickMovesField.add(subtick); 15 | 16 | return subtick; 17 | } -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/cgameentitysystem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: schema field 4 | #include "../../utilities/memory.h" 5 | 6 | #include "../entity_handle.h" 7 | 8 | #define MAX_ENTITIES_IN_LIST 512 9 | #define MAX_ENTITY_LISTS 64 // 0x3F 10 | #define MAX_TOTAL_ENTITIES MAX_ENTITIES_IN_LIST* MAX_ENTITY_LISTS 11 | 12 | class C_BaseEntity; 13 | 14 | class CGameEntitySystem 15 | { 16 | public: 17 | /// GetClientEntity 18 | template 19 | T* Get(int nIndex) 20 | { 21 | return reinterpret_cast(this->GetEntityByIndex(nIndex)); 22 | } 23 | 24 | /// GetClientEntityFromHandle 25 | template 26 | T* Get(const CBaseHandle hHandle) 27 | { 28 | if (!hHandle.IsValid()) 29 | return nullptr; 30 | 31 | return reinterpret_cast(this->GetEntityByIndex(hHandle.GetEntryIndex())); 32 | } 33 | 34 | int GetHighestEntityIndex() 35 | { 36 | return *reinterpret_cast(reinterpret_cast(this) + 0x1510); 37 | } 38 | 39 | private: 40 | void* GetEntityByIndex(int nIndex) 41 | { 42 | //@ida: #STR: "(missing),", "(missing)", "Ent %3d: %s class %s name %s\n" | or find "cl_showents" cvar -> look for callback 43 | // do { pEntity = GetBaseEntityByIndex(g_pGameEntitySystem, nCurrentIndex); ... } 44 | using fnGetBaseEntity = void*(CS_THISCALL*)(void*, int); 45 | static auto GetBaseEntity = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, CS_XOR("81 FA ? ? ? ? 77 ? 8B C2 C1 F8 ? 83 F8 ? 77 ? 48 98 48 8B 4C C1 ? 48 85 C9 74 ? 8B C2 25 ? ? ? ? 48 6B C0 ? 48 03 C8 74 ? 8B 41 ? 25 ? ? ? ? 3B C2 75 ? 48 8B 01"))); 46 | return GetBaseEntity(this, nIndex); 47 | } 48 | }; 49 | 50 | enum CSWeaponID { 51 | GLOCK = 1, 52 | USP_S = 2, 53 | P2000 = 3, 54 | DUAL_BERETTAS = 4, 55 | P250 = 5, 56 | TEC9 = 6, 57 | FIVE_SEVEN = 7, 58 | DESERT_EAGLE = 8, 59 | 60 | MAC10 = 17, 61 | MP9 = 18, 62 | MP7 = 19, 63 | UMP45 = 24, 64 | P90 = 26, 65 | 66 | GALIL_AR = 13, 67 | FAMAS = 14, 68 | AK47 = 10, 69 | M4A4 = 16, 70 | M4A1_S = 20, 71 | AUG = 23, 72 | SG553 = 27, 73 | 74 | AWP = 9, 75 | G3SG1 = 11, 76 | SCAR20 = 38, 77 | 78 | M249 = 28, 79 | NEGEV = 35 80 | }; -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/events.cpp: -------------------------------------------------------------------------------- 1 | #include "events.h" 2 | 3 | std::int64_t IGameEvent::get_int(const std::string_view event_name) noexcept { 4 | // client.dll; 48 89 5C 24 08 48 89 74 24 10 48 89 7C 24 18 41 56 48 83 EC 30 48 8B 01 41 8B F0 4C 8B F1 41 B0 01 48 8D 4C 24 20 48 8B DA 48 8B 78 5 | using function_t = std::int64_t(__fastcall*)(void*, const char*); 6 | static function_t fn = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, "48 89 5C 24 08 48 89 74 24 10 48 89 7C 24 18 41 56 48 83 EC 30 48 8B 01 41 8B F0 4C 8B F1 41 B0 01 48 8D 4C 24 20 48 8B DA 48 8B 78")); 7 | CS_ASSERT(fn != nullptr); 8 | return fn(this, event_name.data()); 9 | } 10 | 11 | void* IGameEvent::get_player_pawn_from_id(const std::string_view event_name) noexcept { 12 | // client.dll; 48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 30 48 8B 01 48 8B F1 41 B0 01 48 8D 4C 24 20 48 8B FA 48 8B 98 13 | using function_t = void*(__fastcall*)(void*, const char*, std::int64_t); 14 | static function_t fn = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, "48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 30 48 8B 01 48 8B F1 41 B0 01 48 8D 4C 24 20 48 8B FA 48 8B 98")); 15 | CS_ASSERT(fn != nullptr); 16 | return fn(this, event_name.data(), 0); 17 | } 18 | 19 | void* IGameEvent::get_pointer_from_id(const std::string_view event_name) noexcept { 20 | // used: "userid", "attackerid" 21 | std::int64_t id{ }; 22 | { 23 | // client.dll; 48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 30 48 8B 01 49 24 | using function_t = std::int64_t(__fastcall*)(void*, std::int64_t*, const char*); 25 | static function_t fn = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, "48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 30 48 8B 01 48 8B F1 41 B0 01 48 8D 4C 24 20 48 8B FA 48 8B 98")); 26 | CS_ASSERT(fn != nullptr); 27 | fn(this, &id, event_name.data()); 28 | } 29 | 30 | if (id == -1) 31 | return { }; 32 | 33 | // xref: "player_disconnect" 34 | // client.dll; E8 ?? ?? ?? ?? 48 8B 0D ?? ?? ?? ?? 48 8B D8 48 85 C9 35 | using function_t2 = void*(__fastcall*)(std::int64_t); 36 | static function_t2 fn = reinterpret_cast(MEM::FindPattern(CLIENT_DLL, "E8 ?? ?? ?? ?? 48 8B 0D ?? ?? ?? ?? 48 8B D8 48 85 C9")); 37 | CS_ASSERT(fn != nullptr); 38 | 39 | return fn(id); 40 | } -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/idebugoverlay.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: find pattern, call virtual function 4 | #include "../../utilities/memory.h" 5 | 6 | // used: vertor_t 7 | #include "../datatypes/vector.h" 8 | // used: color_t 9 | #include "../datatypes/color.h" 10 | 11 | class IDebugOverlayGameSystem 12 | { 13 | public: 14 | // @todo: reverse this 15 | }; -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/iengineclient.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/cstrike/sdk/interfaces/iengineclient.cpp -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/igameresourceservice.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: mem_pad 4 | #include "../../utilities/memory.h" 5 | 6 | class CGameEntitySystem; 7 | 8 | class IGameResourceService 9 | { 10 | public: 11 | MEM_PAD(0x58); 12 | CGameEntitySystem* pGameEntitySystem; 13 | }; -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/iglobalvars.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: mem_pad 4 | #include "../../utilities/memory.h" 5 | 6 | class IGlobalVars 7 | { 8 | public: 9 | float flRealTime; //0x0000 10 | __int32 nFrameCount; //0x0004 11 | float flFrameTime; //0x0008 12 | float flFrameTime2; //0x000C 13 | __int32 mMaxclients; //0x0010 14 | float flIntervalPerTick; //0x0014 15 | __int32 N0000007F; //0x0018 16 | __int32 N0000008B; //0x001C 17 | void* unkfunc; //0x0020 18 | float N00000081; //0x0028 19 | float flCurtime; //0x002C 20 | float flCurtime2; //0x0030 21 | MEM_PAD(0xC); //0x0034 22 | __int32 nTickCount; //0x0040 23 | float flIntervalPerTick2; //0x0044 24 | void* pCurrentNetChannel; //0x0048 25 | MEM_PAD(0x130); //0x0050 26 | char* szCurrentMap; //0x0180 27 | char* szCurrentMapName; //0x0188 28 | 29 | }; //Size=0x0190 30 | 31 | static_assert(sizeof(IGlobalVars) == 0x190); -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/iinputsystem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: getexportaddress 4 | #include "../../utilities/memory.h" 5 | 6 | class IInputSystem 7 | { 8 | public: 9 | bool IsRelativeMouseMode() 10 | { 11 | // @ida: 'IInputSystem::SetRelativeMouseMode'. 12 | return *reinterpret_cast(reinterpret_cast(this) + 0x4F); 13 | } 14 | 15 | void* GetSDLWindow() 16 | { 17 | // @ida: IInputSystem::DebugSpew -> #STR: "Current coordinate bias %s: %g,%g scale %g,%g\n" 18 | return *reinterpret_cast(reinterpret_cast(this) + 0x2678); 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/imemalloc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // used: mem::CallVFunc 3 | #include "../../utilities/memory.h" 4 | #pragma warning(push) 5 | #pragma warning(disable : 4191) 6 | 7 | class IMemAlloc 8 | { 9 | public: 10 | void* Alloc(std::size_t nSize) 11 | { 12 | return MEM::CallVFunc(this, nSize); 13 | } 14 | 15 | void* ReAlloc(const void* pMemory, std::size_t nSize) 16 | { 17 | return MEM::CallVFunc(this, pMemory, nSize); 18 | } 19 | 20 | void Free(const void* pMemory) 21 | { 22 | return MEM::CallVFunc(this, pMemory); 23 | } 24 | 25 | std::size_t GetSize(const void* pMemory) 26 | { 27 | return MEM::CallVFunc(this, pMemory); 28 | } 29 | }; 30 | 31 | #pragma warning(pop) -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/inetworkclientservice.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../../utilities/memory.h" 3 | 4 | class CNetworkGameClient 5 | { 6 | public: 7 | bool IsConnected() 8 | { 9 | return MEM::CallVFunc(this); 10 | } 11 | 12 | // force game to clear cache and reset delta tick 13 | void FullUpdate() 14 | { 15 | // @ida: #STR: "Requesting full game update (%s)...\n" 16 | MEM::CallVFunc(this, CS_XOR("initial update")); 17 | } 18 | void Update() 19 | { 20 | int* deltaTickPtr = reinterpret_cast(reinterpret_cast(this) + 0x258); 21 | 22 | *deltaTickPtr = -1; 23 | } 24 | int GetDeltaTick() 25 | { 26 | // @ida: offset in FullUpdate(); 27 | // (nDeltaTick = -1) == FullUpdate() called 28 | return *reinterpret_cast(reinterpret_cast(this) + 0x258); 29 | } 30 | }; 31 | 32 | class INetworkClientService 33 | { 34 | public: 35 | int deltatick() { 36 | return *reinterpret_cast(reinterpret_cast(this) + 0x258); 37 | } 38 | CNetworkGameClient* GetNetworkClient() { 39 | return MEM::CallVFunc(this); 40 | } 41 | }; -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/iswapchaindx11.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: call virtual function 4 | #include "../../utilities/memory.h" 5 | 6 | // forward declarations 7 | struct IDXGISwapChain; 8 | 9 | class ISwapChainDx11 10 | { 11 | MEM_PAD(0x170); 12 | IDXGISwapChain* pDXGISwapChain; 13 | }; -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/itrace.cpp: -------------------------------------------------------------------------------- 1 | #include "itrace.h" 2 | #include "../cstrike/sdk/interfaces/iengineclient.h" 3 | #include "../cstrike/sdk/interfaces/cgameentitysystem.h" 4 | #include "../cstrike/sdk/interfaces/igameresourceservice.h" 5 | -------------------------------------------------------------------------------- /cstrike/sdk/interfaces/iviewrender.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../datatypes/qangle.h" 4 | #include "../datatypes/matrix.h" 5 | #include "../../core/memaddon.hpp" 6 | class IViewRender 7 | { 8 | public: 9 | Vector_t vecOrigin; // 0x0000 10 | QAngle_t vecAngles; // 0x000C 11 | float flFov; // 0x0018 12 | char pad_0x001C[0x14]; // 0x001C 13 | ViewMatrix_t matUNK1; // 0x0030 14 | char pad_0x0070[0x30]; // 0x0070 15 | ViewMatrix_t matUNK2; // 0x00A0 16 | char pad_0x00E0[0xC8]; // 0x00E0 17 | ViewMatrix_t matUNK3; // 0x01A8 18 | char pad_0x01E8[0x28]; // 0x01E8 19 | }; 20 | #ifndef CS2_CHEAT_CRENDERGAMESYSTEM_HPP 21 | #define CS2_CHEAT_CRENDERGAMESYSTEM_HPP 22 | 23 | 24 | 25 | 26 | #endif // CS2_CHEAT_CRENDERGAMESYSTEM_HPP -------------------------------------------------------------------------------- /cstrike/utilities/fnv1a.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // used: [stl] uint64_t 3 | #include 4 | 5 | // used :CRT::StringLength 6 | #include "crt.h" 7 | 8 | using FNV1A_t = std::uint64_t; 9 | 10 | /* 11 | * 64-BIT FNV1A HASH 12 | */ 13 | namespace HASHCNSX { 14 | 15 | constexpr uint32_t val_32_const = 0x811c9dc5; 16 | constexpr uint32_t prime_32_const = 0x1000193; 17 | 18 | inline constexpr uint32_t hash_32_fnv1a_const(const char* const str, const uint32_t value = val_32_const) noexcept { 19 | return (str[0] == '\0') ? value : hash_32_fnv1a_const(&str[1], (value ^ uint32_t(str[0])) * prime_32_const); 20 | } 21 | } 22 | namespace FNV1A 23 | { 24 | /* @section: [internal] constants */ 25 | constexpr FNV1A_t ullBasis = 0xCBF29CE484222325ULL; 26 | constexpr FNV1A_t ullPrime = 0x100000001B3ULL; 27 | 28 | /* @section: get */ 29 | /// @param[in] szString string for which you want to generate a hash 30 | /// @param[in] uKey key of hash generation 31 | /// @returns: calculated at compile-time hash of given string 32 | consteval FNV1A_t HashConst(const char* szString, const FNV1A_t uKey = ullBasis) noexcept 33 | { 34 | return (szString[0] == '\0') ? uKey : HashConst(&szString[1], (uKey ^ static_cast(szString[0])) * ullPrime); 35 | } 36 | 37 | /// @param[in] szString string for which you want to generate a hash 38 | /// @param[in] uKey key of hash generation 39 | /// @returns: calculated at run-time hash of given string 40 | inline FNV1A_t Hash(const char* szString, FNV1A_t uKey = ullBasis) noexcept 41 | { 42 | const std::size_t nLength = CRT::StringLength(szString); 43 | 44 | for (std::size_t i = 0U; i < nLength; ++i) 45 | { 46 | uKey ^= szString[i]; 47 | uKey *= ullPrime; 48 | } 49 | 50 | return uKey; 51 | } 52 | } -------------------------------------------------------------------------------- /cstrike/utilities/inputsystem.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | // used: [win] winapi 3 | #ifndef WIN32_LEAN_AND_MEAN 4 | #define WIN32_LEAN_AND_MEAN 5 | #endif 6 | #include 7 | 8 | #include "../common.h" 9 | // used: keybind_t 10 | #include "../core/config.h" 11 | 12 | /* 13 | * INPUT SYSTEM 14 | * listen and handle key states 15 | */ 16 | namespace IPT 17 | { 18 | using KeyState_t = std::uint8_t; 19 | 20 | enum EKeyState : KeyState_t 21 | { 22 | KEY_STATE_NONE, 23 | KEY_STATE_DOWN, 24 | KEY_STATE_UP, 25 | KEY_STATE_RELEASED 26 | }; 27 | 28 | /* @section: values */ 29 | // current window 30 | inline HWND hWindow = nullptr; 31 | // saved window messages handler 32 | inline WNDPROC pOldWndProc = nullptr; 33 | // last processed key states 34 | inline KeyState_t arrKeyState[256] = {}; 35 | 36 | // replace game window messages processor with our 37 | bool Setup(); 38 | // restore window messages processor to original 39 | void Destroy(); 40 | 41 | /* @section: callbacks */ 42 | // process input window message and save keys states in array 43 | bool OnWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam); 44 | 45 | /* @section: get */ 46 | /// @returns: true if keybind is active, false otherwise 47 | bool GetBindState(KeyBind_t& keyBind); 48 | 49 | [[nodiscard]] bool IsHovered(const ImVec2& vecPosition, const ImVec2& vecSize); 50 | 51 | /// @returns: true if key is being held, false otherwise 52 | [[nodiscard]] CS_INLINE bool IsKeyDown(const std::uint32_t uButtonCode) 53 | { 54 | return arrKeyState[uButtonCode] == KEY_STATE_DOWN; 55 | } 56 | 57 | /// @returns: true if key has been just released, false otherwise 58 | [[nodiscard]] CS_INLINE bool IsKeyReleased(const std::uint32_t uButtonCode) 59 | { 60 | if (arrKeyState[uButtonCode] == KEY_STATE_RELEASED) 61 | { 62 | arrKeyState[uButtonCode] = KEY_STATE_UP; 63 | return true; 64 | } 65 | 66 | return false; 67 | } 68 | } -------------------------------------------------------------------------------- /cstrike/utilities/notify.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // used: [stl] vector 4 | #include 5 | // used: draw wrapper 6 | #include "draw.h" 7 | 8 | #pragma region notify_definitions 9 | #define NOFITY_TEXT_SIZE 64U // max size of notification text 10 | // @todo: use ImStyle? 11 | #define NOTIFY_ANIMATION_TIME 15.0 // time in ms to show/hide notification 12 | #define NOTIFY_DELETE_TIME 30.0 // time in ms to delete notification 13 | #pragma endregion 14 | 15 | #pragma region notify_enumerations 16 | using NotificationType_t = int; 17 | 18 | enum ENotificationType : NotificationType_t 19 | { 20 | N_TYPE_DEFAULT = 0, 21 | N_TYPE_INFO, 22 | N_TYPE_SUCCESS, 23 | N_TYPE_WARNING, 24 | N_TYPE_ERROR, 25 | N_TYPE_MAX 26 | }; 27 | 28 | using NotificationState_t = int; 29 | 30 | enum ENotificationState : NotificationState_t 31 | { 32 | N_STATE_START = 0, 33 | N_STATE_STAY, 34 | N_STATE_END, 35 | N_STATE_EXPIRED, 36 | N_STATE_MAX 37 | }; 38 | 39 | #pragma endregion 40 | 41 | namespace NOTIFY 42 | { 43 | struct NotificationData_t 44 | { 45 | NotificationData_t(ENotificationType nType, const char* szFormat, ...); 46 | 47 | /// @return color of notification type 48 | const Color_t& GetTypeColor() const; 49 | /// @return c-type string of notification text 50 | const char* Data() const; 51 | /// @return icon of notification type 52 | const char* GetIcon() const; 53 | /// @return time difference between creation and current time 54 | const float GetTimeDelta(const float flCurrentTime) const; 55 | 56 | int nType = 0; 57 | char szBuffer[NOFITY_TEXT_SIZE]; 58 | float flCreateionTime = 0.0; 59 | AnimationHandler_t animHandler = AnimationHandler_t(); 60 | }; 61 | 62 | /* @section: main */ 63 | // push notification to queue 64 | void Push(const NotificationData_t& notification); 65 | // pop notification from queue 66 | void _Remove(size_t nIndex); 67 | // render notifications 68 | void Render(); 69 | 70 | /* @section: values */ 71 | // maximum time to show notification 72 | inline constexpr float _MAX_TIME = 5.f; 73 | // maximum count of notifications 74 | inline std::vector vecNotifications = {}; 75 | } -------------------------------------------------------------------------------- /dependencies/freetype/binary/freetype.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/dependencies/freetype/binary/freetype.lib -------------------------------------------------------------------------------- /dependencies/freetype/binary/freetype_debug.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/dependencies/freetype/binary/freetype_debug.lib -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/config/ftmodule.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file registers the FreeType modules compiled into the library. 3 | * 4 | * If you use GNU make, this file IS NOT USED! Instead, it is created in 5 | * the objects directory (normally `/objs/`) based on information 6 | * from `/modules.cfg`. 7 | * 8 | * Please read `docs/INSTALL.ANY` and `docs/CUSTOMIZE` how to compile 9 | * FreeType without GNU make. 10 | * 11 | */ 12 | 13 | FT_USE_MODULE( FT_Module_Class, autofit_module_class ) 14 | FT_USE_MODULE( FT_Driver_ClassRec, tt_driver_class ) 15 | FT_USE_MODULE( FT_Driver_ClassRec, t1_driver_class ) 16 | FT_USE_MODULE( FT_Driver_ClassRec, cff_driver_class ) 17 | FT_USE_MODULE( FT_Driver_ClassRec, t1cid_driver_class ) 18 | FT_USE_MODULE( FT_Driver_ClassRec, pfr_driver_class ) 19 | FT_USE_MODULE( FT_Driver_ClassRec, t42_driver_class ) 20 | FT_USE_MODULE( FT_Driver_ClassRec, winfnt_driver_class ) 21 | FT_USE_MODULE( FT_Driver_ClassRec, pcf_driver_class ) 22 | FT_USE_MODULE( FT_Module_Class, psaux_module_class ) 23 | FT_USE_MODULE( FT_Module_Class, psnames_module_class ) 24 | FT_USE_MODULE( FT_Module_Class, pshinter_module_class ) 25 | FT_USE_MODULE( FT_Renderer_Class, ft_raster1_renderer_class ) 26 | FT_USE_MODULE( FT_Module_Class, sfnt_module_class ) 27 | FT_USE_MODULE( FT_Renderer_Class, ft_smooth_renderer_class ) 28 | FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcd_renderer_class ) 29 | FT_USE_MODULE( FT_Renderer_Class, ft_smooth_lcdv_renderer_class ) 30 | FT_USE_MODULE( FT_Driver_ClassRec, bdf_driver_class ) 31 | 32 | /* EOF */ 33 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/ftfntfmt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftfntfmt.h 4 | * 5 | * Support functions for font formats. 6 | * 7 | * Copyright (C) 2002-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef FTFNTFMT_H_ 20 | #define FTFNTFMT_H_ 21 | 22 | #include 23 | #include FT_FREETYPE_H 24 | 25 | #ifdef FREETYPE_H 26 | #error "freetype.h of FreeType 1 has been loaded!" 27 | #error "Please fix the directory search order for header files" 28 | #error "so that freetype.h of FreeType 2 is found first." 29 | #endif 30 | 31 | 32 | FT_BEGIN_HEADER 33 | 34 | 35 | /************************************************************************** 36 | * 37 | * @section: 38 | * font_formats 39 | * 40 | * @title: 41 | * Font Formats 42 | * 43 | * @abstract: 44 | * Getting the font format. 45 | * 46 | * @description: 47 | * The single function in this section can be used to get the font format. 48 | * Note that this information is not needed normally; however, there are 49 | * special cases (like in PDF devices) where it is important to 50 | * differentiate, in spite of FreeType's uniform API. 51 | * 52 | */ 53 | 54 | 55 | /************************************************************************** 56 | * 57 | * @function: 58 | * FT_Get_Font_Format 59 | * 60 | * @description: 61 | * Return a string describing the format of a given face. Possible values 62 | * are 'TrueType', 'Type~1', 'BDF', 'PCF', 'Type~42', 'CID~Type~1', 'CFF', 63 | * 'PFR', and 'Windows~FNT'. 64 | * 65 | * The return value is suitable to be used as an X11 FONT_PROPERTY. 66 | * 67 | * @input: 68 | * face :: 69 | * Input face handle. 70 | * 71 | * @return: 72 | * Font format string. `NULL` in case of error. 73 | * 74 | * @note: 75 | * A deprecated name for the same function is `FT_Get_X11_Font_Format`. 76 | */ 77 | FT_EXPORT( const char* ) 78 | FT_Get_Font_Format( FT_Face face ); 79 | 80 | 81 | /* deprecated */ 82 | FT_EXPORT( const char* ) 83 | FT_Get_X11_Font_Format( FT_Face face ); 84 | 85 | 86 | /* */ 87 | 88 | 89 | FT_END_HEADER 90 | 91 | #endif /* FTFNTFMT_H_ */ 92 | 93 | 94 | /* END */ 95 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/ftpsprop.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ftpsprop.h 4 | * 5 | * Get and set properties of PostScript drivers (specification). 6 | * 7 | * Copyright (C) 2017-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef FTPSPROP_H_ 20 | #define FTPSPROP_H_ 21 | 22 | 23 | #include 24 | #include FT_FREETYPE_H 25 | 26 | 27 | FT_BEGIN_HEADER 28 | 29 | 30 | FT_BASE_CALLBACK( FT_Error ) 31 | ps_property_set( FT_Module module, /* PS_Driver */ 32 | const char* property_name, 33 | const void* value, 34 | FT_Bool value_is_string ); 35 | 36 | FT_BASE_CALLBACK( FT_Error ) 37 | ps_property_get( FT_Module module, /* PS_Driver */ 38 | const char* property_name, 39 | void* value ); 40 | 41 | 42 | FT_END_HEADER 43 | 44 | 45 | #endif /* FTPSPROP_H_ */ 46 | 47 | 48 | /* END */ 49 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svbdf.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svbdf.h 4 | * 5 | * The FreeType BDF services (specification). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVBDF_H_ 20 | #define SVBDF_H_ 21 | 22 | #include FT_BDF_H 23 | #include FT_INTERNAL_SERVICE_H 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_BDF "bdf" 30 | 31 | typedef FT_Error 32 | (*FT_BDF_GetCharsetIdFunc)( FT_Face face, 33 | const char* *acharset_encoding, 34 | const char* *acharset_registry ); 35 | 36 | typedef FT_Error 37 | (*FT_BDF_GetPropertyFunc)( FT_Face face, 38 | const char* prop_name, 39 | BDF_PropertyRec *aproperty ); 40 | 41 | 42 | FT_DEFINE_SERVICE( BDF ) 43 | { 44 | FT_BDF_GetCharsetIdFunc get_charset_id; 45 | FT_BDF_GetPropertyFunc get_property; 46 | }; 47 | 48 | 49 | #define FT_DEFINE_SERVICE_BDFRec( class_, \ 50 | get_charset_id_, \ 51 | get_property_ ) \ 52 | static const FT_Service_BDFRec class_ = \ 53 | { \ 54 | get_charset_id_, get_property_ \ 55 | }; 56 | 57 | /* */ 58 | 59 | 60 | FT_END_HEADER 61 | 62 | 63 | #endif /* SVBDF_H_ */ 64 | 65 | 66 | /* END */ 67 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svcid.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svcid.h 4 | * 5 | * The FreeType CID font services (specification). 6 | * 7 | * Copyright (C) 2007-2019 by 8 | * Derek Clegg and Michael Toftdal. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVCID_H_ 20 | #define SVCID_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | #define FT_SERVICE_ID_CID "CID" 29 | 30 | typedef FT_Error 31 | (*FT_CID_GetRegistryOrderingSupplementFunc)( FT_Face face, 32 | const char* *registry, 33 | const char* *ordering, 34 | FT_Int *supplement ); 35 | typedef FT_Error 36 | (*FT_CID_GetIsInternallyCIDKeyedFunc)( FT_Face face, 37 | FT_Bool *is_cid ); 38 | typedef FT_Error 39 | (*FT_CID_GetCIDFromGlyphIndexFunc)( FT_Face face, 40 | FT_UInt glyph_index, 41 | FT_UInt *cid ); 42 | 43 | FT_DEFINE_SERVICE( CID ) 44 | { 45 | FT_CID_GetRegistryOrderingSupplementFunc get_ros; 46 | FT_CID_GetIsInternallyCIDKeyedFunc get_is_cid; 47 | FT_CID_GetCIDFromGlyphIndexFunc get_cid_from_glyph_index; 48 | }; 49 | 50 | 51 | #define FT_DEFINE_SERVICE_CIDREC( class_, \ 52 | get_ros_, \ 53 | get_is_cid_, \ 54 | get_cid_from_glyph_index_ ) \ 55 | static const FT_Service_CIDRec class_ = \ 56 | { \ 57 | get_ros_, get_is_cid_, get_cid_from_glyph_index_ \ 58 | }; 59 | 60 | /* */ 61 | 62 | 63 | FT_END_HEADER 64 | 65 | 66 | #endif /* SVCID_H_ */ 67 | 68 | 69 | /* END */ 70 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svfntfmt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svfntfmt.h 4 | * 5 | * The FreeType font format service (specification only). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVFNTFMT_H_ 20 | #define SVFNTFMT_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | /* 29 | * A trivial service used to return the name of a face's font driver, 30 | * according to the XFree86 nomenclature. Note that the service data is a 31 | * simple constant string pointer. 32 | */ 33 | 34 | #define FT_SERVICE_ID_FONT_FORMAT "font-format" 35 | 36 | #define FT_FONT_FORMAT_TRUETYPE "TrueType" 37 | #define FT_FONT_FORMAT_TYPE_1 "Type 1" 38 | #define FT_FONT_FORMAT_BDF "BDF" 39 | #define FT_FONT_FORMAT_PCF "PCF" 40 | #define FT_FONT_FORMAT_TYPE_42 "Type 42" 41 | #define FT_FONT_FORMAT_CID "CID Type 1" 42 | #define FT_FONT_FORMAT_CFF "CFF" 43 | #define FT_FONT_FORMAT_PFR "PFR" 44 | #define FT_FONT_FORMAT_WINFNT "Windows FNT" 45 | 46 | /* */ 47 | 48 | 49 | FT_END_HEADER 50 | 51 | 52 | #endif /* SVFNTFMT_H_ */ 53 | 54 | 55 | /* END */ 56 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svgldict.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svgldict.h 4 | * 5 | * The FreeType glyph dictionary services (specification). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVGLDICT_H_ 20 | #define SVGLDICT_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | /* 29 | * A service used to retrieve glyph names, as well as to find the index of 30 | * a given glyph name in a font. 31 | * 32 | */ 33 | 34 | #define FT_SERVICE_ID_GLYPH_DICT "glyph-dict" 35 | 36 | 37 | typedef FT_Error 38 | (*FT_GlyphDict_GetNameFunc)( FT_Face face, 39 | FT_UInt glyph_index, 40 | FT_Pointer buffer, 41 | FT_UInt buffer_max ); 42 | 43 | typedef FT_UInt 44 | (*FT_GlyphDict_NameIndexFunc)( FT_Face face, 45 | FT_String* glyph_name ); 46 | 47 | 48 | FT_DEFINE_SERVICE( GlyphDict ) 49 | { 50 | FT_GlyphDict_GetNameFunc get_name; 51 | FT_GlyphDict_NameIndexFunc name_index; /* optional */ 52 | }; 53 | 54 | 55 | #define FT_DEFINE_SERVICE_GLYPHDICTREC( class_, \ 56 | get_name_, \ 57 | name_index_ ) \ 58 | static const FT_Service_GlyphDictRec class_ = \ 59 | { \ 60 | get_name_, name_index_ \ 61 | }; 62 | 63 | /* */ 64 | 65 | 66 | FT_END_HEADER 67 | 68 | 69 | #endif /* SVGLDICT_H_ */ 70 | 71 | 72 | /* END */ 73 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svgxval.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svgxval.h 4 | * 5 | * FreeType API for validating TrueTypeGX/AAT tables (specification). 6 | * 7 | * Copyright (C) 2004-2019 by 8 | * Masatake YAMATO, Red Hat K.K., 9 | * David Turner, Robert Wilhelm, and Werner Lemberg. 10 | * 11 | * This file is part of the FreeType project, and may only be used, 12 | * modified, and distributed under the terms of the FreeType project 13 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 14 | * this file you indicate that you have read the license and 15 | * understand and accept it fully. 16 | * 17 | */ 18 | 19 | /**************************************************************************** 20 | * 21 | * gxvalid is derived from both gxlayout module and otvalid module. 22 | * Development of gxlayout is supported by the Information-technology 23 | * Promotion Agency(IPA), Japan. 24 | * 25 | */ 26 | 27 | 28 | #ifndef SVGXVAL_H_ 29 | #define SVGXVAL_H_ 30 | 31 | #include FT_GX_VALIDATE_H 32 | #include FT_INTERNAL_VALIDATE_H 33 | 34 | FT_BEGIN_HEADER 35 | 36 | 37 | #define FT_SERVICE_ID_GX_VALIDATE "truetypegx-validate" 38 | #define FT_SERVICE_ID_CLASSICKERN_VALIDATE "classickern-validate" 39 | 40 | typedef FT_Error 41 | (*gxv_validate_func)( FT_Face face, 42 | FT_UInt gx_flags, 43 | FT_Bytes tables[FT_VALIDATE_GX_LENGTH], 44 | FT_UInt table_length ); 45 | 46 | 47 | typedef FT_Error 48 | (*ckern_validate_func)( FT_Face face, 49 | FT_UInt ckern_flags, 50 | FT_Bytes *ckern_table ); 51 | 52 | 53 | FT_DEFINE_SERVICE( GXvalidate ) 54 | { 55 | gxv_validate_func validate; 56 | }; 57 | 58 | FT_DEFINE_SERVICE( CKERNvalidate ) 59 | { 60 | ckern_validate_func validate; 61 | }; 62 | 63 | /* */ 64 | 65 | 66 | FT_END_HEADER 67 | 68 | 69 | #endif /* SVGXVAL_H_ */ 70 | 71 | 72 | /* END */ 73 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svkern.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svkern.h 4 | * 5 | * The FreeType Kerning service (specification). 6 | * 7 | * Copyright (C) 2006-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVKERN_H_ 20 | #define SVKERN_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | #include FT_TRUETYPE_TABLES_H 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | #define FT_SERVICE_ID_KERNING "kerning" 29 | 30 | 31 | typedef FT_Error 32 | (*FT_Kerning_TrackGetFunc)( FT_Face face, 33 | FT_Fixed point_size, 34 | FT_Int degree, 35 | FT_Fixed* akerning ); 36 | 37 | FT_DEFINE_SERVICE( Kerning ) 38 | { 39 | FT_Kerning_TrackGetFunc get_track; 40 | }; 41 | 42 | /* */ 43 | 44 | 45 | FT_END_HEADER 46 | 47 | 48 | #endif /* SVKERN_H_ */ 49 | 50 | 51 | /* END */ 52 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svotval.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svotval.h 4 | * 5 | * The FreeType OpenType validation service (specification). 6 | * 7 | * Copyright (C) 2004-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVOTVAL_H_ 20 | #define SVOTVAL_H_ 21 | 22 | #include FT_OPENTYPE_VALIDATE_H 23 | #include FT_INTERNAL_VALIDATE_H 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | #define FT_SERVICE_ID_OPENTYPE_VALIDATE "opentype-validate" 29 | 30 | 31 | typedef FT_Error 32 | (*otv_validate_func)( FT_Face volatile face, 33 | FT_UInt ot_flags, 34 | FT_Bytes *base, 35 | FT_Bytes *gdef, 36 | FT_Bytes *gpos, 37 | FT_Bytes *gsub, 38 | FT_Bytes *jstf ); 39 | 40 | 41 | FT_DEFINE_SERVICE( OTvalidate ) 42 | { 43 | otv_validate_func validate; 44 | }; 45 | 46 | /* */ 47 | 48 | 49 | FT_END_HEADER 50 | 51 | 52 | #endif /* SVOTVAL_H_ */ 53 | 54 | 55 | /* END */ 56 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svpfr.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svpfr.h 4 | * 5 | * Internal PFR service functions (specification). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPFR_H_ 20 | #define SVPFR_H_ 21 | 22 | #include FT_PFR_H 23 | #include FT_INTERNAL_SERVICE_H 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_PFR_METRICS "pfr-metrics" 30 | 31 | 32 | typedef FT_Error 33 | (*FT_PFR_GetMetricsFunc)( FT_Face face, 34 | FT_UInt *aoutline, 35 | FT_UInt *ametrics, 36 | FT_Fixed *ax_scale, 37 | FT_Fixed *ay_scale ); 38 | 39 | typedef FT_Error 40 | (*FT_PFR_GetKerningFunc)( FT_Face face, 41 | FT_UInt left, 42 | FT_UInt right, 43 | FT_Vector *avector ); 44 | 45 | typedef FT_Error 46 | (*FT_PFR_GetAdvanceFunc)( FT_Face face, 47 | FT_UInt gindex, 48 | FT_Pos *aadvance ); 49 | 50 | 51 | FT_DEFINE_SERVICE( PfrMetrics ) 52 | { 53 | FT_PFR_GetMetricsFunc get_metrics; 54 | FT_PFR_GetKerningFunc get_kerning; 55 | FT_PFR_GetAdvanceFunc get_advance; 56 | 57 | }; 58 | 59 | /* */ 60 | 61 | FT_END_HEADER 62 | 63 | #endif /* SVPFR_H_ */ 64 | 65 | 66 | /* END */ 67 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svpostnm.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svpostnm.h 4 | * 5 | * The FreeType PostScript name services (specification). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPOSTNM_H_ 20 | #define SVPOSTNM_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | /* 28 | * A trivial service used to retrieve the PostScript name of a given font 29 | * when available. The `get_name' field should never be `NULL`. 30 | * 31 | * The corresponding function can return `NULL` to indicate that the 32 | * PostScript name is not available. 33 | * 34 | * The name is owned by the face and will be destroyed with it. 35 | */ 36 | 37 | #define FT_SERVICE_ID_POSTSCRIPT_FONT_NAME "postscript-font-name" 38 | 39 | 40 | typedef const char* 41 | (*FT_PsName_GetFunc)( FT_Face face ); 42 | 43 | 44 | FT_DEFINE_SERVICE( PsFontName ) 45 | { 46 | FT_PsName_GetFunc get_ps_font_name; 47 | }; 48 | 49 | 50 | #define FT_DEFINE_SERVICE_PSFONTNAMEREC( class_, get_ps_font_name_ ) \ 51 | static const FT_Service_PsFontNameRec class_ = \ 52 | { \ 53 | get_ps_font_name_ \ 54 | }; 55 | 56 | /* */ 57 | 58 | 59 | FT_END_HEADER 60 | 61 | 62 | #endif /* SVPOSTNM_H_ */ 63 | 64 | 65 | /* END */ 66 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svprop.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svprop.h 4 | * 5 | * The FreeType property service (specification). 6 | * 7 | * Copyright (C) 2012-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVPROP_H_ 20 | #define SVPROP_H_ 21 | 22 | 23 | FT_BEGIN_HEADER 24 | 25 | 26 | #define FT_SERVICE_ID_PROPERTIES "properties" 27 | 28 | 29 | typedef FT_Error 30 | (*FT_Properties_SetFunc)( FT_Module module, 31 | const char* property_name, 32 | const void* value, 33 | FT_Bool value_is_string ); 34 | 35 | typedef FT_Error 36 | (*FT_Properties_GetFunc)( FT_Module module, 37 | const char* property_name, 38 | void* value ); 39 | 40 | 41 | FT_DEFINE_SERVICE( Properties ) 42 | { 43 | FT_Properties_SetFunc set_property; 44 | FT_Properties_GetFunc get_property; 45 | }; 46 | 47 | 48 | #define FT_DEFINE_SERVICE_PROPERTIESREC( class_, \ 49 | set_property_, \ 50 | get_property_ ) \ 51 | static const FT_Service_PropertiesRec class_ = \ 52 | { \ 53 | set_property_, \ 54 | get_property_ \ 55 | }; 56 | 57 | /* */ 58 | 59 | 60 | FT_END_HEADER 61 | 62 | 63 | #endif /* SVPROP_H_ */ 64 | 65 | 66 | /* END */ 67 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svsfnt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svsfnt.h 4 | * 5 | * The FreeType SFNT table loading service (specification). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVSFNT_H_ 20 | #define SVSFNT_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | #include FT_TRUETYPE_TABLES_H 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | /* 30 | * SFNT table loading service. 31 | */ 32 | 33 | #define FT_SERVICE_ID_SFNT_TABLE "sfnt-table" 34 | 35 | 36 | /* 37 | * Used to implement FT_Load_Sfnt_Table(). 38 | */ 39 | typedef FT_Error 40 | (*FT_SFNT_TableLoadFunc)( FT_Face face, 41 | FT_ULong tag, 42 | FT_Long offset, 43 | FT_Byte* buffer, 44 | FT_ULong* length ); 45 | 46 | /* 47 | * Used to implement FT_Get_Sfnt_Table(). 48 | */ 49 | typedef void* 50 | (*FT_SFNT_TableGetFunc)( FT_Face face, 51 | FT_Sfnt_Tag tag ); 52 | 53 | 54 | /* 55 | * Used to implement FT_Sfnt_Table_Info(). 56 | */ 57 | typedef FT_Error 58 | (*FT_SFNT_TableInfoFunc)( FT_Face face, 59 | FT_UInt idx, 60 | FT_ULong *tag, 61 | FT_ULong *offset, 62 | FT_ULong *length ); 63 | 64 | 65 | FT_DEFINE_SERVICE( SFNT_Table ) 66 | { 67 | FT_SFNT_TableLoadFunc load_table; 68 | FT_SFNT_TableGetFunc get_table; 69 | FT_SFNT_TableInfoFunc table_info; 70 | }; 71 | 72 | 73 | #define FT_DEFINE_SERVICE_SFNT_TABLEREC( class_, load_, get_, info_ ) \ 74 | static const FT_Service_SFNT_TableRec class_ = \ 75 | { \ 76 | load_, get_, info_ \ 77 | }; 78 | 79 | /* */ 80 | 81 | 82 | FT_END_HEADER 83 | 84 | 85 | #endif /* SVSFNT_H_ */ 86 | 87 | 88 | /* END */ 89 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svttcmap.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svttcmap.h 4 | * 5 | * The FreeType TrueType/sfnt cmap extra information service. 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * Masatake YAMATO, Redhat K.K., 9 | * David Turner, Robert Wilhelm, and Werner Lemberg. 10 | * 11 | * This file is part of the FreeType project, and may only be used, 12 | * modified, and distributed under the terms of the FreeType project 13 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 14 | * this file you indicate that you have read the license and 15 | * understand and accept it fully. 16 | * 17 | */ 18 | 19 | /* Development of this service is support of 20 | Information-technology Promotion Agency, Japan. */ 21 | 22 | #ifndef SVTTCMAP_H_ 23 | #define SVTTCMAP_H_ 24 | 25 | #include FT_INTERNAL_SERVICE_H 26 | #include FT_TRUETYPE_TABLES_H 27 | 28 | 29 | FT_BEGIN_HEADER 30 | 31 | 32 | #define FT_SERVICE_ID_TT_CMAP "tt-cmaps" 33 | 34 | 35 | /************************************************************************** 36 | * 37 | * @struct: 38 | * TT_CMapInfo 39 | * 40 | * @description: 41 | * A structure used to store TrueType/sfnt specific cmap information 42 | * which is not covered by the generic @FT_CharMap structure. This 43 | * structure can be accessed with the @FT_Get_TT_CMap_Info function. 44 | * 45 | * @fields: 46 | * language :: 47 | * The language ID used in Mac fonts. Definitions of values are in 48 | * `ttnameid.h`. 49 | * 50 | * format :: 51 | * The cmap format. OpenType 1.6 defines the formats 0 (byte encoding 52 | * table), 2~(high-byte mapping through table), 4~(segment mapping to 53 | * delta values), 6~(trimmed table mapping), 8~(mixed 16-bit and 32-bit 54 | * coverage), 10~(trimmed array), 12~(segmented coverage), 13~(last 55 | * resort font), and 14 (Unicode Variation Sequences). 56 | */ 57 | typedef struct TT_CMapInfo_ 58 | { 59 | FT_ULong language; 60 | FT_Long format; 61 | 62 | } TT_CMapInfo; 63 | 64 | 65 | typedef FT_Error 66 | (*TT_CMap_Info_GetFunc)( FT_CharMap charmap, 67 | TT_CMapInfo *cmap_info ); 68 | 69 | 70 | FT_DEFINE_SERVICE( TTCMaps ) 71 | { 72 | TT_CMap_Info_GetFunc get_cmap_info; 73 | }; 74 | 75 | 76 | #define FT_DEFINE_SERVICE_TTCMAPSREC( class_, get_cmap_info_ ) \ 77 | static const FT_Service_TTCMapsRec class_ = \ 78 | { \ 79 | get_cmap_info_ \ 80 | }; 81 | 82 | /* */ 83 | 84 | 85 | FT_END_HEADER 86 | 87 | #endif /* SVTTCMAP_H_ */ 88 | 89 | 90 | /* END */ 91 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svtteng.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svtteng.h 4 | * 5 | * The FreeType TrueType engine query service (specification). 6 | * 7 | * Copyright (C) 2006-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVTTENG_H_ 20 | #define SVTTENG_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | #include FT_MODULE_H 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | /* 30 | * SFNT table loading service. 31 | */ 32 | 33 | #define FT_SERVICE_ID_TRUETYPE_ENGINE "truetype-engine" 34 | 35 | /* 36 | * Used to implement FT_Get_TrueType_Engine_Type 37 | */ 38 | 39 | FT_DEFINE_SERVICE( TrueTypeEngine ) 40 | { 41 | FT_TrueTypeEngineType engine_type; 42 | }; 43 | 44 | /* */ 45 | 46 | 47 | FT_END_HEADER 48 | 49 | 50 | #endif /* SVTTENG_H_ */ 51 | 52 | 53 | /* END */ 54 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svttglyf.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svttglyf.h 4 | * 5 | * The FreeType TrueType glyph service. 6 | * 7 | * Copyright (C) 2007-2019 by 8 | * David Turner. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | #ifndef SVTTGLYF_H_ 19 | #define SVTTGLYF_H_ 20 | 21 | #include FT_INTERNAL_SERVICE_H 22 | #include FT_TRUETYPE_TABLES_H 23 | 24 | 25 | FT_BEGIN_HEADER 26 | 27 | 28 | #define FT_SERVICE_ID_TT_GLYF "tt-glyf" 29 | 30 | 31 | typedef FT_ULong 32 | (*TT_Glyf_GetLocationFunc)( FT_Face face, 33 | FT_UInt gindex, 34 | FT_ULong *psize ); 35 | 36 | FT_DEFINE_SERVICE( TTGlyf ) 37 | { 38 | TT_Glyf_GetLocationFunc get_location; 39 | }; 40 | 41 | 42 | #define FT_DEFINE_SERVICE_TTGLYFREC( class_, get_location_ ) \ 43 | static const FT_Service_TTGlyfRec class_ = \ 44 | { \ 45 | get_location_ \ 46 | }; 47 | 48 | /* */ 49 | 50 | 51 | FT_END_HEADER 52 | 53 | #endif /* SVTTGLYF_H_ */ 54 | 55 | 56 | /* END */ 57 | -------------------------------------------------------------------------------- /dependencies/freetype/include/freetype/internal/services/svwinfnt.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * svwinfnt.h 4 | * 5 | * The FreeType Windows FNT/FONT service (specification). 6 | * 7 | * Copyright (C) 2003-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | #ifndef SVWINFNT_H_ 20 | #define SVWINFNT_H_ 21 | 22 | #include FT_INTERNAL_SERVICE_H 23 | #include FT_WINFONTS_H 24 | 25 | 26 | FT_BEGIN_HEADER 27 | 28 | 29 | #define FT_SERVICE_ID_WINFNT "winfonts" 30 | 31 | typedef FT_Error 32 | (*FT_WinFnt_GetHeaderFunc)( FT_Face face, 33 | FT_WinFNT_HeaderRec *aheader ); 34 | 35 | 36 | FT_DEFINE_SERVICE( WinFnt ) 37 | { 38 | FT_WinFnt_GetHeaderFunc get_header; 39 | }; 40 | 41 | /* */ 42 | 43 | 44 | FT_END_HEADER 45 | 46 | 47 | #endif /* SVWINFNT_H_ */ 48 | 49 | 50 | /* END */ 51 | -------------------------------------------------------------------------------- /dependencies/freetype/include/ft2build.h: -------------------------------------------------------------------------------- 1 | /**************************************************************************** 2 | * 3 | * ft2build.h 4 | * 5 | * FreeType 2 build and setup macros. 6 | * 7 | * Copyright (C) 1996-2019 by 8 | * David Turner, Robert Wilhelm, and Werner Lemberg. 9 | * 10 | * This file is part of the FreeType project, and may only be used, 11 | * modified, and distributed under the terms of the FreeType project 12 | * license, LICENSE.TXT. By continuing to use, modify, or distribute 13 | * this file you indicate that you have read the license and 14 | * understand and accept it fully. 15 | * 16 | */ 17 | 18 | 19 | /************************************************************************** 20 | * 21 | * This is the 'entry point' for FreeType header file inclusions. It is 22 | * the only header file which should be included directly; all other 23 | * FreeType header files should be accessed with macro names (after 24 | * including `ft2build.h`). 25 | * 26 | * A typical example is 27 | * 28 | * ``` 29 | * #include 30 | * #include FT_FREETYPE_H 31 | * ``` 32 | * 33 | */ 34 | 35 | 36 | #ifndef FT2BUILD_H_ 37 | #define FT2BUILD_H_ 38 | 39 | #include 40 | 41 | #endif /* FT2BUILD_H_ */ 42 | 43 | 44 | /* END */ 45 | -------------------------------------------------------------------------------- /dependencies/imgui/imgui_impl_dx11.h: -------------------------------------------------------------------------------- 1 | // dear imgui: Renderer Backend for DirectX11 2 | // This needs to be used along with a Platform Backend (e.g. Win32) 3 | 4 | // Implemented features: 5 | // [X] Renderer: User texture binding. Use 'ID3D11ShaderResourceView*' as ImTextureID. Read the FAQ about ImTextureID! 6 | // [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices. 7 | 8 | // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this. 9 | // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need. 10 | // If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp. 11 | // Read online: https://github.com/ocornut/imgui/tree/master/docs 12 | 13 | #pragma once 14 | #include "imgui.h" // IMGUI_IMPL_API 15 | #ifndef IMGUI_DISABLE 16 | 17 | struct ID3D11Device; 18 | struct ID3D11DeviceContext; 19 | 20 | IMGUI_IMPL_API bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context); 21 | IMGUI_IMPL_API void ImGui_ImplDX11_Shutdown(); 22 | IMGUI_IMPL_API void ImGui_ImplDX11_NewFrame(); 23 | IMGUI_IMPL_API void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data); 24 | 25 | // Use if you want to reset your rendering device without losing Dear ImGui state. 26 | IMGUI_IMPL_API void ImGui_ImplDX11_InvalidateDeviceObjects(); 27 | IMGUI_IMPL_API bool ImGui_ImplDX11_CreateDeviceObjects(); 28 | 29 | #endif // #ifndef IMGUI_DISABLE 30 | -------------------------------------------------------------------------------- /dependencies/imgui/imgui_settings.h: -------------------------------------------------------------------------------- 1 | #include "imgui.h" 2 | 3 | inline float dpi = 1.0f; 4 | 5 | namespace font 6 | { 7 | inline ImFont* icomoon = nullptr; 8 | inline ImFont* lexend_bold = nullptr; 9 | inline ImFont* lexend_regular = nullptr; 10 | inline ImFont* lexend_general_bold = nullptr; 11 | 12 | inline ImFont* icomoon_widget = nullptr; 13 | inline ImFont* icomoon_widget2 = nullptr; 14 | 15 | } 16 | 17 | namespace c 18 | { 19 | 20 | inline ImVec4 accent = ImColor(112, 110, 215); 21 | 22 | namespace background 23 | { 24 | 25 | inline ImVec4 filling = ImColor(12, 12, 12); 26 | inline ImVec4 stroke = ImColor(24, 26, 36); 27 | inline ImVec2 size = ImVec2(850, 515); 28 | 29 | inline float rounding = 6; 30 | 31 | } 32 | 33 | namespace elements 34 | { 35 | inline ImVec4 mark = ImColor(255, 255, 255); 36 | 37 | inline ImVec4 stroke = ImColor(28, 26, 37); 38 | inline ImVec4 background = ImColor(15, 15, 17); 39 | inline ImVec4 background_widget = ImColor(21, 23, 26); 40 | 41 | inline ImVec4 text_active = ImColor(255, 255, 255); 42 | inline ImVec4 text_hov = ImColor(81, 92, 109); 43 | inline ImVec4 text = ImColor(43, 51, 63); 44 | 45 | inline float rounding = 4; 46 | } 47 | 48 | namespace child 49 | { 50 | 51 | } 52 | 53 | namespace tab 54 | { 55 | inline ImVec4 tab_active = ImColor(22, 22, 30); 56 | 57 | inline ImVec4 border = ImColor(14, 14, 15); 58 | } 59 | 60 | } -------------------------------------------------------------------------------- /dependencies/minhook/buffer.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/dependencies/minhook/buffer.c -------------------------------------------------------------------------------- /dependencies/minhook/buffer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MinHook - The Minimalistic API Hooking Library for x64/x86 3 | * Copyright (C) 2009-2017 Tsuda Kageyu. 4 | * All rights reserved. 5 | * 6 | * Redistribution and use in source and binary forms, with or without 7 | * modification, are permitted provided that the following conditions 8 | * are met: 9 | * 10 | * 1. Redistributions of source code must retain the above copyright 11 | * notice, this list of conditions and the following disclaimer. 12 | * 2. Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 19 | * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER 20 | * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 23 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 24 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 25 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 26 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 | */ 28 | 29 | #pragma once 30 | 31 | // Size of each memory slot. 32 | #if defined(_M_X64) || defined(__x86_64__) 33 | #define MEMORY_SLOT_SIZE 64 34 | #else 35 | #define MEMORY_SLOT_SIZE 32 36 | #endif 37 | 38 | VOID InitializeBuffer(VOID); 39 | VOID UninitializeBuffer(VOID); 40 | LPVOID AllocateBuffer(LPVOID pOrigin); 41 | VOID FreeBuffer(LPVOID pBuffer); 42 | BOOL IsExecutableAddress(LPVOID pAddress); 43 | -------------------------------------------------------------------------------- /dependencies/minhook/hde/pstdint.h: -------------------------------------------------------------------------------- 1 | /* 2 | * MinHook - The Minimalistic API Hooking Library for x64/x86 3 | * Copyright (C) 2009-2017 Tsuda Kageyu. All rights reserved. 4 | * 5 | * Redistribution and use in source and binary forms, with or without 6 | * modification, are permitted provided that the following conditions 7 | * are met: 8 | * 9 | * 1. Redistributions of source code must retain the above copyright 10 | * notice, this list of conditions and the following disclaimer. 11 | * 2. Redistributions in binary form must reproduce the above copyright 12 | * notice, this list of conditions and the following disclaimer in the 13 | * documentation and/or other materials provided with the distribution. 14 | * 15 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR 16 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 | */ 26 | 27 | #pragma once 28 | 29 | #include 30 | 31 | // Integer types for HDE. 32 | typedef INT8 int8_t; 33 | typedef INT16 int16_t; 34 | typedef INT32 int32_t; 35 | typedef INT64 int64_t; 36 | typedef UINT8 uint8_t; 37 | typedef UINT16 uint16_t; 38 | typedef UINT32 uint32_t; 39 | typedef UINT64 uint64_t; 40 | -------------------------------------------------------------------------------- /resources/README.md: -------------------------------------------------------------------------------- 1 | # game_icons.h 2 | * game's weapon, c4... icons 3 | 4 | # smallest_pixel.h 5 | * smallest pixel font 6 | 7 | # font_awesome_5.h && fa_solid_900.h 8 | * font awesome 5 -------------------------------------------------------------------------------- /sddefault.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/T1GxR/Axion-CS2-RAGE-CHEAT/5e174c1f07b96f5bcaa5c9a09045d0c082325d93/sddefault.jpg --------------------------------------------------------------------------------