├── Darkside_Chams ├── Chams.h └── main.cpp ├── Fwd_Chams ├── Chams.h └── main.cpp ├── Henzry_Chams ├── Chams.h └── main.cpp ├── Norka_Chams ├── Chams.h ├── RGB.h └── main.cpp ├── README.md └── Rapid_Chams ├── Chams.h └── main.cpp /Darkside_Chams/Chams.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | static void *handle; 7 | static const char* shaderName; 8 | static bool enableWallhack; 9 | static bool enableWallhackW; 10 | static bool enableWallhackG; 11 | static bool enableWallhackO; 12 | static bool enableRainbow; 13 | static bool enableRainbow1; 14 | static float r = 0; 15 | static float g = 0; 16 | static float b = 0; 17 | static int w = 0; 18 | static int a = 0; 19 | 20 | float red = 0; 21 | float gren = 0; 22 | float blue =0; 23 | float mi = 0; 24 | 25 | void setShader(const char* s) { 26 | shaderName = s; 27 | } 28 | const char* getShader() { 29 | return shaderName; 30 | } 31 | 32 | void SetWallhack(bool enable){ 33 | enableWallhack = enable; 34 | } 35 | 36 | void SetWallhackW(bool enable){ 37 | enableWallhackW = enable; 38 | } 39 | 40 | void SetWallhackG(bool enable){ 41 | enableWallhackG = enable; 42 | } 43 | 44 | void SetWallhackO(bool enable){ 45 | enableWallhackO = enable; 46 | } 47 | 48 | void SetRainbow(bool enable){ 49 | enableRainbow = enable; 50 | } 51 | void SetRainbow1(bool enable){ 52 | enableRainbow1 = enable; 53 | } 54 | 55 | void SetR(int set){ 56 | r = set; 57 | } 58 | 59 | void SetG(int set){ 60 | g = set; 61 | } 62 | 63 | void SetB(int set){ 64 | b = set; 65 | } 66 | 67 | void SetW(int set){ 68 | w = set; 69 | } 70 | 71 | bool getWallhackEnabled(){ 72 | return enableWallhack; 73 | } 74 | 75 | bool getWireframeEnabled(){ 76 | return enableWallhackW; 77 | } 78 | 79 | bool getGlowEnabled(){ 80 | return enableWallhackG; 81 | } 82 | 83 | bool getOutlineEnabled(){ 84 | return enableWallhackO; 85 | } 86 | 87 | bool getRainbowEnabled(){ 88 | return enableRainbow; 89 | } 90 | bool getRainbow1Enabled(){ 91 | return enableRainbow1; 92 | } 93 | 94 | int (*old_glGetUniformLocation)(GLuint, const GLchar *); 95 | GLint new_glGetUniformLocation(GLuint program, const GLchar *name) { 96 | 97 | return old_glGetUniformLocation(program, name); 98 | } 99 | 100 | bool isCurrentShader(const char *shader) { 101 | GLint currProgram; 102 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 103 | return old_glGetUniformLocation(currProgram, shader) != -1; 104 | } 105 | 106 | void (*old_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); 107 | void new_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { 108 | old_glDrawElements(mode, count, type, indices); 109 | if (mode != GL_TRIANGLES || count < 1000) return; 110 | { 111 | GLint currProgram; 112 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 113 | 114 | GLint id = old_glGetUniformLocation(currProgram, getShader()); 115 | if (id == -1) return; 116 | 117 | if (getWireframeEnabled()) { 118 | 119 | if (enableWallhackW) { 120 | glDepthRangef(1, 0.5); 121 | } 122 | else { 123 | glDepthRangef(0.5, 1); 124 | } 125 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 126 | glColorMask(1, 1, 1, 1); 127 | glEnable(GL_BLEND); 128 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 129 | glLineWidth(w); 130 | old_glDrawElements(GL_LINE_LOOP, count, type, indices); 131 | } 132 | 133 | 134 | if (getWallhackEnabled()) { 135 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), GLfloat(a/255)); 136 | glColorMask(r, g, b, 255); 137 | glEnable(GL_BLEND); 138 | glBlendFunc(GL_CONSTANT_ALPHA, GL_CONSTANT_COLOR); 139 | } 140 | 141 | if (getGlowEnabled()) { 142 | glEnable(GL_BLEND); 143 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 144 | glColorMask(1, 1, 1, 1); 145 | glEnable(GL_BLEND); 146 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 147 | glLineWidth(15); 148 | 149 | glDepthRangef(0.5, 1); 150 | old_glDrawElements(GL_LINES, count, type, indices); 151 | glBlendColor(1, 1, 1, 1); 152 | glDepthRangef(1, 0.5); 153 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 154 | } 155 | 156 | if (getOutlineEnabled()) { 157 | glDepthRangef(1, 0.5); 158 | glLineWidth(20.0f); 159 | glEnable(GL_BLEND); 160 | glColorMask(1, 1, 1, 1); 161 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 162 | glBlendColor(0, 0, 0, 1); 163 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 164 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 165 | old_glDrawElements(GL_LINES, count, type, indices); 166 | } 167 | 168 | if (getRainbowEnabled()) { 169 | if(getRainbow1Enabled){ 170 | if (red == 255){ 171 | if (blue == 0 ){ 172 | if (gren == 255){} else{ 173 | gren = gren+1; 174 | } 175 | } 176 | } 177 | if (gren == 255){ 178 | if (red == 0){} else{ 179 | red = red-1; 180 | } 181 | } 182 | if (gren == 255) { 183 | if (red == 0) { 184 | if (blue==255){} else{ 185 | blue = blue+1; 186 | } 187 | } 188 | } 189 | if (blue == 255) { 190 | if (gren == 0) { 191 | mi = 1; 192 | red = red+1; 193 | } 194 | else{ 195 | gren = gren-1; 196 | } 197 | } 198 | if (mi == 1){ 199 | if (red == 255){ 200 | if (blue == 0){} else{ 201 | blue = blue-1; 202 | } 203 | } 204 | } 205 | SetR(red); 206 | SetG(gren); 207 | SetB(blue); 208 | } 209 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), GLfloat(a/255)); 210 | glColorMask(1, 1, 1, 1); 211 | glEnable(GL_BLEND); 212 | glBlendFunc(GL_ONE_MINUS_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_ALPHA); 213 | 214 | } 215 | old_glDrawElements(mode, count, type, indices); 216 | 217 | glDepthRangef(0.5, 1); 218 | 219 | glColorMask(1, 1, 1, 1); 220 | glDisable(GL_BLEND); 221 | } 222 | } 223 | 224 | bool mlovinit(){ 225 | handle = NULL; 226 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 227 | if(!handle){ 228 | return false; 229 | } 230 | return true; 231 | } 232 | 233 | void LogShaders(){ 234 | auto p_glGetUniformLocation = (const void*(*)(...))dlsym(handle, "glGetUniformLocation"); 235 | const char *dlsym_error = dlerror(); 236 | if(dlsym_error){ 237 | return; 238 | }else{ 239 | MSHookFunction(reinterpret_cast(p_glGetUniformLocation), reinterpret_cast(new_glGetUniformLocation), reinterpret_cast(&old_glGetUniformLocation)); 240 | } 241 | } 242 | 243 | void Wallhack(){ 244 | auto p_glDrawElements = (const void*(*)(...))dlsym(handle, "glDrawElements"); 245 | const char *dlsym_error = dlerror(); 246 | if(dlsym_error){ 247 | return; 248 | }else{ 249 | MSHookFunction(reinterpret_cast(p_glDrawElements), reinterpret_cast(new_glDrawElements), reinterpret_cast(&old_glDrawElements)); 250 | } 251 | } 252 | 253 | -------------------------------------------------------------------------------- /Darkside_Chams/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include "Includes/Chams.h" 14 | 15 | #include 16 | #include 17 | 18 | #define libName OBFUSCATE("libil2cpp.so") 19 | 20 | bool underground, wireframe, glow, outline, chams, wchams, rainbow; 21 | 22 | void *hack_thread(void *) { 23 | ProcMap il2cppMap; 24 | do { 25 | il2cppMap = KittyMemory::getLibraryMap("libil2cpp.so"); 26 | sleep(1); 27 | } while (!isLibraryLoaded(libName) && mlovinit()); 28 | setShader("_BumpMap"); 29 | LogShaders(); 30 | Wallhack(); 31 | 32 | return NULL; 33 | } 34 | 35 | const char *features[] = { 36 | OBFUSCATE("Toggle_Default Chams"),//0 37 | OBFUSCATE("Toggle_Wireframe Chams"),//1 38 | OBFUSCATE("Toggle_Glow Chams"),//2 39 | OBFUSCATE("Toggle_Outline Chams"),//3 40 | OBFUSCATE("Toggle_Rainbow Chams"),//4 41 | OBFUSCATE("SeekBar_Line Width_0_10"),//5 42 | OBFUSCATE("SeekBar_Color Red_0_255"),//6 43 | OBFUSCATE("SeekBar_Color Green_0_255"),//7 44 | OBFUSCATE("SeekBar_Color Blue_0_255"),//8 45 | }; 46 | 47 | switch (featNum) { 48 | case 3: 49 | chams = boolean; 50 | if (chams) { 51 | SetWallhack(true); 52 | } else { 53 | SetWallhack(false); 54 | } 55 | break; 56 | case 4: 57 | wireframe = boolean; 58 | if (wireframe) { 59 | SetWallhackW(true); 60 | } else { 61 | SetWallhackW(false); 62 | } 63 | break; 64 | case 5: 65 | glow = boolean; 66 | if (glow) { 67 | SetWallhackG(true); 68 | } else { 69 | SetWallhackG(false); 70 | } 71 | break; 72 | case 6: 73 | outline = boolean; 74 | if (outline) { 75 | SetWallhackO(true); 76 | } else { 77 | SetWallhackO(false); 78 | } 79 | break; 80 | case 7: 81 | rainbow = boolean; 82 | if (rainbow) { 83 | SetRainbow(true); 84 | } else { 85 | SetRainbow(false); 86 | } 87 | break; 88 | case 8: 89 | SetW(value); 90 | break; 91 | case 9: 92 | SetR(value); 93 | break; 94 | case 10: 95 | SetG(value); 96 | break; 97 | case 11: 98 | SetB(value); 99 | 100 | -------------------------------------------------------------------------------- /Fwd_Chams/Chams.h: -------------------------------------------------------------------------------- 1 | #ifndef FWD_ASSAULT_CHAMS_H 2 | #define FWD_ASSAULT_CHAMS_H 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | bool rgb,chams,chamsr,llchmms,chjk,war,ott = false; 9 | int r,g,b; 10 | int rr,gg,bb; 11 | int ro,go,bo; 12 | 13 | static void *handle; 14 | static const char* shaderName; 15 | static bool enableWallhack, cvhj, hhgg, sosypisu, rgb3, wh3, rgb1; 16 | 17 | void setShader(const char* s) { 18 | shaderName = s; 19 | } 20 | const char* getShader() { 21 | return shaderName; 22 | } 23 | 24 | void SetWireframe(bool enable){ 25 | enableWallhack = enable; 26 | } 27 | 28 | void SetChams(bool enable){ 29 | cvhj = enable; 30 | } 31 | 32 | void SetOutline(bool enable){ 33 | sosypisu = enable; 34 | } 35 | 36 | void SetR(int set){ 37 | r = set; 38 | } 39 | 40 | void SetG(int set){ 41 | g = set; 42 | } 43 | 44 | void SetB(int set){ 45 | b = set; 46 | } 47 | 48 | void SetRR(int sett){ 49 | rr = sett; 50 | } 51 | 52 | void SetGG(int sett){ 53 | gg = sett; 54 | } 55 | 56 | void SetBB(int sett){ 57 | bb = sett; 58 | } 59 | 60 | void SetRO(int seto){ 61 | ro = seto; 62 | } 63 | 64 | void SetGO(int seto){ 65 | go = seto; 66 | } 67 | 68 | void SetBO(int seto){ 69 | bo = seto; 70 | } 71 | 72 | bool getWallhackEnabled(){ 73 | return enableWallhack; 74 | } 75 | 76 | int (*old_glGetUniformLocation)(GLuint, const GLchar *); 77 | GLint new_glGetUniformLocation(GLuint program, const GLchar *name) { 78 | //Log name to find used shaders. 79 | LOGI("New shader found: %s", name); 80 | return old_glGetUniformLocation(program, name); 81 | } 82 | 83 | bool isCurrentShader(const char *shader) { 84 | GLint currProgram; 85 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 86 | return old_glGetUniformLocation(currProgram, shader) != -1; 87 | } 88 | 89 | void (*old_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); 90 | void new_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { 91 | old_glDrawElements(mode, count, type, indices); 92 | if (mode != GL_TRIANGLES || count < 1000) return; 93 | { 94 | GLint currProgram; 95 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 96 | 97 | GLint id = old_glGetUniformLocation(currProgram, getShader()); 98 | if (id == -1) return; 99 | 100 | if (getWallhackEnabled()) { 101 | glDepthRangef(1, 0.5); 102 | glBlendColor(GLfloat(r/100), GLfloat(g/100), GLfloat(b/100), GLfloat(1)); 103 | glColorMask(1, 1, 1, 1); 104 | glEnable(GL_BLEND); 105 | glBlendFunc(GL_CONSTANT_ALPHA, GL_CONSTANT_COLOR); 106 | 107 | } 108 | 109 | old_glDrawElements(GL_LINES, count, type, indices); 110 | 111 | 112 | glDepthRangef(0.5, 1); 113 | 114 | glColorMask(1, 1, 1, 1); 115 | glDisable(GL_BLEND); 116 | } 117 | if (cvhj) { 118 | glDepthRangef(1, 0.5); 119 | glBlendColor(GLfloat(rr/100), GLfloat(gg/100), GLfloat(bb/100), GLfloat(1)); 120 | glColorMask(1, 1, 1, 1); 121 | glEnable(GL_BLEND); 122 | glBlendFunc(GL_CONSTANT_ALPHA, GL_CONSTANT_COLOR); 123 | 124 | } 125 | 126 | old_glDrawElements(mode, count, type, indices); 127 | 128 | 129 | glDepthRangef(0.5, 1); 130 | 131 | glColorMask(1, 1, 1, 1); 132 | glDisable(GL_BLEND); 133 | 134 | if (sosypisu) { 135 | 136 | glDepthRangef(1, 0); 137 | glLineWidth(20.0f); 138 | glEnable(GL_BLEND); 139 | glColorMask(1, 1, 1, 1); 140 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 141 | glBlendColor(0, 0, 0, 1); 142 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 143 | glBlendColor(GLfloat(ro/100), GLfloat(go/100), GLfloat(bo/100), 1); 144 | if (wh3) { 145 | glDepthRangef(1, 0.5); 146 | } 147 | else { 148 | glDepthRangef(0.5, 1); 149 | } 150 | if (rgb3) { 151 | glBlendColor(GLfloat(float(r)/255), GLfloat(float(g)/255), GLfloat(float(b)/255), 1); 152 | } 153 | old_glDrawElements(GL_LINES, count, type, indices); 154 | glDepthMask(true); 155 | glDepthFunc(GL_LESS); 156 | } 157 | } 158 | 159 | bool mlovinit(){ 160 | handle = NULL; 161 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 162 | if(!handle){ 163 | LOGE("Cannot open library: %s", dlerror()); 164 | return false; 165 | } 166 | return true; 167 | } 168 | 169 | void LogShaders(){ 170 | auto p_glGetUniformLocation = (const void*(*)(...))dlsym(handle, "glGetUniformLocation"); 171 | const char *dlsym_error = dlerror(); 172 | if(dlsym_error){ 173 | LOGE("Cannot load symbol 'glGetUniformLocation': %s", dlsym_error); 174 | return; 175 | }else{ 176 | MSHookFunction(reinterpret_cast(p_glGetUniformLocation), reinterpret_cast(new_glGetUniformLocation), reinterpret_cast(&old_glGetUniformLocation)); 177 | } 178 | } 179 | 180 | void Wallhack(){ 181 | auto p_glDrawElements = (const void*(*)(...))dlsym(handle, "glDrawElements"); 182 | const char *dlsym_error = dlerror(); 183 | if(dlsym_error){ 184 | LOGE("Cannot load symbol 'glDrawElements': %s", dlsym_error); 185 | return; 186 | }else{ 187 | MSHookFunction(reinterpret_cast(p_glDrawElements), reinterpret_cast(new_glDrawElements), reinterpret_cast(&old_glDrawElements)); 188 | } 189 | } 190 | 191 | #endif //FWD_ASSAULT_CHAMS_H 192 | -------------------------------------------------------------------------------- /Fwd_Chams/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 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 "Chams.h" 18 | #include 19 | #include 20 | 21 | #include 22 | #include 23 | 24 | const char *features[] = { 25 | "Text_Chams Menu", 26 | "Button_Wireframe Red", 27 | "Button_Wireframe Green", 28 | "Button_Wireframe Blue", 29 | "Button_Wireframe Yellow", 30 | "Button_Wireframe Pink", 31 | "Button_Wireframe White", 32 | "Button_Chams Red", 33 | "Button_Chams Green", 34 | "Button_Chams Blue", 35 | "Button_Chams Yellow", 36 | "Button_Chams Pink", 37 | "Button_Chams White", 38 | "Button_Outline Red", 39 | "Button_Outline Green", 40 | "Button_Outline Blue", 41 | "Button_Outline Yellow", 42 | "Button_Outline Pink", 43 | "Button_Outline White", 44 | "}; 45 | 46 | bool chr, chgr, chblu, chyelo, chpin, chwhit; 47 | bool chrr, chgrr, chblur, chyelor, chpinr, chwhitr; 48 | bool chro, chgro, chbluo, chyeloo, chpino, chwhito; 49 | 50 | switch (feature) { 51 | case 1: 52 | chr = !chr; 53 | if (chr) { 54 | SetWireframe(true); 55 | SetR(255); 56 | SetG(0); 57 | SetB(0); 58 | } else { 59 | SetWireframe(false); 60 | } 61 | break; 62 | case 2: 63 | chgr = !chgr; 64 | if (chgr) { 65 | SetWireframe(true); 66 | SetR(0); 67 | SetG(255); 68 | SetB(0); 69 | } else { 70 | SetWireframe(false); 71 | } 72 | break; 73 | case 3: 74 | chblu = !chblu; 75 | if (chblu) { 76 | SetWireframe(true); 77 | SetR(0); 78 | SetG(0); 79 | SetB(255); 80 | } else { 81 | SetWireframe(false); 82 | } 83 | break; 84 | case 4: 85 | chyelo = !chyelo; 86 | if (chyelo) { 87 | SetWireframe(true); 88 | SetR(255); 89 | SetG(255); 90 | SetB(0); 91 | } else { 92 | SetWireframe(false); 93 | } 94 | break; 95 | case 5: 96 | chpin = !chpin; 97 | if (chpin) { 98 | SetWireframe(true); 99 | SetR(255); 100 | SetG(0); 101 | SetB(255); 102 | } else { 103 | SetWireframe(false); 104 | } 105 | break; 106 | case 6: 107 | chwhit = !chwhit; 108 | if (chwhit) { 109 | SetWireframe(true); 110 | SetR(255); 111 | SetG(255); 112 | SetB(255); 113 | } else { 114 | SetWireframe(false); 115 | } 116 | break; 117 | case 7: 118 | chrr = !chrr; 119 | if (chrr) { 120 | SetChams(true); 121 | SetRR(255); 122 | SetGG(0); 123 | SetBB(0); 124 | } else { 125 | SetChams(false); 126 | } 127 | break; 128 | case 8: 129 | chgrr = !chgrr; 130 | if (chgrr) { 131 | SetChams(true); 132 | SetRR(0); 133 | SetGG(255); 134 | SetBB(0); 135 | } else { 136 | SetChams(false); 137 | } 138 | break; 139 | case 9: 140 | chblur = !chblur; 141 | if (chblur) { 142 | SetChams(true); 143 | SetRR(0); 144 | SetGG(0); 145 | SetBB(255); 146 | } else { 147 | SetChams(false); 148 | } 149 | break; 150 | case 10: 151 | chyelor = !chyelor; 152 | if (chyelor) { 153 | SetChams(true); 154 | SetRR(255); 155 | SetGG(255); 156 | SetBB(0); 157 | } else { 158 | SetChams(false); 159 | } 160 | break; 161 | case 11: 162 | chpinr = !chpinr; 163 | if (chpinr) { 164 | SetChams(true); 165 | SetRR(255); 166 | SetGG(0); 167 | SetBB(255); 168 | } else { 169 | SetChams(false); 170 | } 171 | break; 172 | case 12: 173 | chwhitr = !chwhitr; 174 | if (chwhitr) { 175 | SetChams(true); 176 | SetRR(255); 177 | SetGG(255); 178 | SetBB(255); 179 | } else { 180 | SetChams(false); 181 | } 182 | break; 183 | case 13: 184 | chro = !chro; 185 | if (chro) { 186 | SetOutline(true); 187 | SetRO(255); 188 | SetGO(0); 189 | SetBO(0); 190 | } else { 191 | SetOutline(false); 192 | } 193 | break; 194 | case 14: 195 | chgro = !chgro; 196 | if (chgro) { 197 | SetOutline(true); 198 | SetRO(0); 199 | SetGO(255); 200 | SetBO(0); 201 | } else { 202 | SetOutline(false); 203 | } 204 | break; 205 | case 15: 206 | chbluo = !chbluo; 207 | if (chbluo) { 208 | SetOutline(true); 209 | SetRO(0); 210 | SetGO(0); 211 | SetBO(255); 212 | } else { 213 | SetOutline(false); 214 | } 215 | break; 216 | case 16: 217 | chyeloo = !chyeloo; 218 | if (chyeloo) { 219 | SetOutline(true); 220 | SetRO(255); 221 | SetGO(255); 222 | SetBO(0); 223 | } else { 224 | SetOutline(false); 225 | } 226 | break; 227 | case 17: 228 | chpino = !chpino; 229 | if (chpino) { 230 | SetOutline(true); 231 | SetRO(255); 232 | SetGO(0); 233 | SetBO(255); 234 | } else { 235 | SetOutline(false); 236 | } 237 | break; 238 | case 18: 239 | chwhito = !chwhito; 240 | if (chwhito) { 241 | SetOutline(true); 242 | SetRO(255); 243 | SetGO(255); 244 | SetBO(255); 245 | } else { 246 | SetOutline(false); 247 | } 248 | break; 249 | case 19: 250 | jump = !jump; 251 | if (jump) { 252 | hexPatches.Airjump.Modify(); 253 | } else { 254 | hexPatches.Airjump.Restore(); 255 | } 256 | break; 257 | } 258 | } 259 | 260 | const char *libName = "libil2cpp.so"; 261 | 262 | void *hack_thread(void *) { 263 | 264 | ProcMap il2cppMap; 265 | do { 266 | il2cppMap = KittyMemory::getLibraryMap(libName); 267 | sleep(1); 268 | } while (!il2cppMap.isValid() && mlovinit()); 269 | setShader("_BumpMap"); 270 | LogShaders(); 271 | Wallhack(); 272 | 273 | } 274 | -------------------------------------------------------------------------------- /Henzry_Chams/Chams.h: -------------------------------------------------------------------------------- 1 | #ifndef HENZRY_CHAMS 2 | #define HENZRY_CHAMS 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | static void *handle; 9 | static const char* shaderName; 10 | static bool enableWallhack; 11 | static bool enableWallhackS; 12 | static bool enableWallhackW; 13 | static bool enableWallhackG; 14 | static bool enableWallhackO; 15 | static bool enableRainbow; 16 | static bool enableRainbow1; 17 | static float r = 255.0f; 18 | static float g = 0.0f; 19 | static float b = 0.0f; 20 | static int w = 1; 21 | static int a = 255; 22 | 23 | float red = 255.0f; 24 | float gren = 0.0f; 25 | float blue =0.0f; 26 | float mi = 0.0f; 27 | 28 | void setShader(const char* s) { 29 | shaderName = s; 30 | } 31 | const char* getShader() { 32 | return shaderName; 33 | } 34 | 35 | void SetWallhack(bool enable){ 36 | enableWallhack = enable; 37 | } 38 | 39 | void SetWallhackS(bool enable){ 40 | enableWallhackS = enable; 41 | } 42 | 43 | void SetWallhackW(bool enable){ 44 | enableWallhackW = enable; 45 | } 46 | 47 | void SetWallhackG(bool enable){ 48 | enableWallhackG = enable; 49 | } 50 | 51 | void SetWallhackO(bool enable){ 52 | enableWallhackO = enable; 53 | } 54 | 55 | void SetRainbow(bool enable){ 56 | enableRainbow = enable; 57 | } 58 | void SetRainbow1(bool enable){ 59 | enableRainbow1 = enable; 60 | } 61 | 62 | void SetR(int set){ 63 | r = set; 64 | } 65 | 66 | void SetG(int set){ 67 | g = set; 68 | } 69 | 70 | void SetB(int set){ 71 | b = set; 72 | } 73 | 74 | void SetW(int set){ 75 | w = set; 76 | } 77 | 78 | bool getWallhackEnabled(){ 79 | return enableWallhack; 80 | } 81 | 82 | bool getShadingEnabled(){ 83 | return enableWallhackS; 84 | } 85 | 86 | bool getWireframeEnabled(){ 87 | return enableWallhackW; 88 | } 89 | 90 | bool getGlowEnabled(){ 91 | return enableWallhackG; 92 | } 93 | 94 | bool getOutlineEnabled(){ 95 | return enableWallhackO; 96 | } 97 | 98 | bool getRainbowEnabled(){ 99 | return enableRainbow; 100 | } 101 | bool getRainbow1Enabled(){ 102 | return enableRainbow1; 103 | } 104 | 105 | int (*old_glGetUniformLocation)(GLuint, const GLchar *); 106 | GLint new_glGetUniformLocation(GLuint program, const GLchar *name) { 107 | return old_glGetUniformLocation(program, name); 108 | } 109 | 110 | bool isCurrentShader(const char *shader) { 111 | GLint currProgram; 112 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 113 | return old_glGetUniformLocation(currProgram, shader) != -1; 114 | } 115 | 116 | void (*old_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); 117 | void new_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { 118 | old_glDrawElements(mode, count, type, indices); 119 | if (mode != GL_TRIANGLES || count < 1000) return; 120 | { 121 | GLint currProgram; 122 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 123 | 124 | GLint id = old_glGetUniformLocation(currProgram, getShader()); 125 | if (id == -1) return; 126 | 127 | if (getWireframeEnabled()) { 128 | 129 | if (enableWallhackW) { 130 | glDepthRangef(1, 0.5); 131 | } 132 | else { 133 | glDepthRangef(0.5, 1); 134 | } 135 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 136 | glColorMask(1, 1, 1, 1); 137 | glEnable(GL_BLEND); 138 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 139 | glLineWidth(w); 140 | old_glDrawElements(GL_LINE_LOOP, count, type, indices); 141 | } 142 | 143 | 144 | if (getWallhackEnabled()) { 145 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), GLfloat(a/255)); 146 | glColorMask(r, g, b, 255); 147 | glEnable(GL_BLEND); 148 | glBlendFunc(GL_CONSTANT_ALPHA, GL_CONSTANT_COLOR); 149 | } 150 | 151 | if (getShadingEnabled()) { 152 | glDepthRangef(1, 0.5); 153 | glEnable(GL_BLEND); 154 | glBlendFunc(GL_SRC_COLOR, GL_CONSTANT_COLOR); 155 | glBlendEquation(GL_FUNC_ADD); 156 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 157 | glDepthFunc(GL_ALWAYS); 158 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 159 | glColorMask(r, g, b, 255); 160 | glBlendFunc(GL_DST_COLOR, GL_ONE); 161 | glDepthFunc(GL_LESS); 162 | glBlendColor(0.0, 0.0, 0.0, 0.0); 163 | } 164 | 165 | if (getGlowEnabled()) { 166 | glEnable(GL_BLEND); 167 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 168 | glColorMask(1, 1, 1, 1); 169 | glEnable(GL_BLEND); 170 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 171 | glLineWidth(w); 172 | 173 | glDepthRangef(0.5, 1); 174 | old_glDrawElements(GL_LINES, count, type, indices); 175 | glBlendColor(1, 1, 1, 1); 176 | glDepthRangef(1, 0.5); 177 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 178 | } 179 | 180 | if (getOutlineEnabled()) { 181 | glDepthRangef(1, 0.5); 182 | glLineWidth(w); 183 | glEnable(GL_BLEND); 184 | glColorMask(1, 1, 1, 1); 185 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 186 | glBlendColor(0, 0, 0, 1); 187 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 188 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 189 | old_glDrawElements(GL_LINES, count, type, indices); 190 | } 191 | 192 | if (getRainbowEnabled()) { 193 | if(getRainbow1Enabled){ 194 | if (red == 255){ 195 | if (blue == 0 ){ 196 | if (gren == 255){} else{ 197 | gren = gren+1; 198 | } 199 | } 200 | } 201 | if (gren == 255){ 202 | if (red == 0){} else{ 203 | red = red-1; 204 | } 205 | } 206 | if (gren == 255) { 207 | if (red == 0) { 208 | if (blue==255){} else{ 209 | blue = blue+1; 210 | } 211 | } 212 | } 213 | if (blue == 255) { 214 | if (gren == 0) { 215 | mi = 1; 216 | red = red+1; 217 | } 218 | else{ 219 | gren = gren-1; 220 | } 221 | } 222 | if (mi == 1){ 223 | if (red == 255){ 224 | if (blue == 0){} else{ 225 | blue = blue-1; 226 | } 227 | } 228 | } 229 | SetR(red); 230 | SetG(gren); 231 | SetB(blue); 232 | } 233 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), GLfloat(a/255)); 234 | glColorMask(1, 1, 1, 1); 235 | glEnable(GL_BLEND); 236 | glBlendFunc(GL_ONE_MINUS_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_ALPHA); 237 | 238 | } 239 | old_glDrawElements(mode, count, type, indices); 240 | 241 | glDepthRangef(0.5, 1); 242 | 243 | glColorMask(1, 1, 1, 1); 244 | glDisable(GL_BLEND); 245 | } 246 | } 247 | 248 | bool mlovinit(){ 249 | handle = NULL; 250 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 251 | if(!handle){ 252 | return false; 253 | } 254 | return true; 255 | } 256 | 257 | void LogShaders(){ 258 | auto p_glGetUniformLocation = (const void*(*)(...))dlsym(handle, "glGetUniformLocation"); 259 | const char *dlsym_error = dlerror(); 260 | if(dlsym_error){ 261 | return; 262 | }else{ 263 | MSHookFunction(reinterpret_cast(p_glGetUniformLocation), reinterpret_cast(new_glGetUniformLocation), reinterpret_cast(&old_glGetUniformLocation)); 264 | } 265 | } 266 | 267 | void Wallhack(){ 268 | auto p_glDrawElements = (const void*(*)(...))dlsym(handle, "glDrawElements"); 269 | const char *dlsym_error = dlerror(); 270 | if(dlsym_error){ 271 | return; 272 | }else{ 273 | MSHookFunction(reinterpret_cast(p_glDrawElements), reinterpret_cast(new_glDrawElements), reinterpret_cast(&old_glDrawElements)); 274 | } 275 | } 276 | 277 | 278 | #endif 279 | 280 | -------------------------------------------------------------------------------- /Henzry_Chams/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | bool chams, shading, wireframe, glow, outline, rainbow = false; 7 | 8 | const char *features[] = { 9 | "Text_Chams Menu︎", //0 10 | "Button_Default Chams",//1 11 | "Button_Shading Chams", //2 12 | "Button_Wireframe Chams",//3 13 | "Button_Glow Chams",//4 14 | "Button_Outline Chams", //5 15 | "Button_Rainbow Chams", //6 16 | "Seek_Line Width_0_12",//7 17 | "Seek_Color R_0_255",//8 18 | "Seek_Color G_0_255",//9 19 | "Seek_Color B_0_255",//10 20 | }; 21 | 22 | switch (feature) { 23 | case 1: 24 | chams = !chams; 25 | if (chams) { 26 | SetWallhack(true); 27 | } else { 28 | SetWallhack(false); 29 | } 30 | break; 31 | case 2: 32 | shading = !shading; 33 | if (shading) { 34 | SetWallhackS(true); 35 | } else { 36 | SetWallhackS(false); 37 | } 38 | break; 39 | case 3: 40 | wireframe = !wireframe; 41 | if (wireframe) { 42 | SetWallhackW(true); 43 | } else { 44 | SetWallhackW(false); 45 | } 46 | break; 47 | case 4: 48 | glow = !glow; 49 | if (glow) { 50 | SetWallhackG(true); 51 | } else { 52 | SetWallhackG(false); 53 | } 54 | break; 55 | case 5: 56 | outline = !outline; 57 | if (outline) { 58 | SetWallhackO(true); 59 | } else { 60 | SetWallhackO(false); 61 | } 62 | break; 63 | case 6: 64 | rainbow = !rainbow; 65 | if (rainbow) { 66 | SetRainbow(true); 67 | } else { 68 | SetRainbow(false); 69 | } 70 | break; 71 | case 7: 72 | SetW(value); 73 | break; 74 | case 8: 75 | SetR(value); 76 | break; 77 | case 9: 78 | SetG(value); 79 | break; 80 | case 10: 81 | SetB(value); 82 | break; 83 | 84 | void *hack_thread(void *) { 85 | 86 | ProcMap il2cppMap; 87 | do { 88 | il2cppMap = KittyMemory::getLibraryMap(libName); 89 | sleep(1); 90 | } while (!il2cppMap.isValid() && mlovinit()); 91 | setShader("_BumpMap"); 92 | LogShaders(); 93 | Wallhack(); 94 | 95 | return NULL; 96 | } 97 | -------------------------------------------------------------------------------- /Norka_Chams/Chams.h: -------------------------------------------------------------------------------- 1 | #ifndef NORKA_CHAMS 2 | #define NORKA_CHAMS 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "RGB.h" 9 | 10 | static void *handle; 11 | static const char* shaderName; 12 | static bool enableWallhack; 13 | static bool enableWallhackW; 14 | static bool enableWallhackG; 15 | static bool enableWallhackO; 16 | static bool enableSkyColor; 17 | static bool enableRainbow; 18 | bool isRGB = false; 19 | static float r = 255.0f; 20 | static float g = 0.0f; 21 | static float b = 0.0f; 22 | static int w = 2; 23 | static float gw = 7.0f; 24 | static float ow = 6.0f; 25 | static int a = 255; 26 | 27 | float red = 255.0f; 28 | float gren = 0.0f; 29 | float blue =0.0f; 30 | float mi = 0.0f; 31 | 32 | void setShader(const char* s) { 33 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 34 | shaderName = s; 35 | } 36 | 37 | const char* getShader() { 38 | return shaderName; 39 | } 40 | 41 | void SetWallhack(bool enable){ 42 | enableWallhack = enable; 43 | } 44 | 45 | void SetWireframe(bool enable){ 46 | enableWallhackW = enable; 47 | } 48 | 49 | void SetGlow(bool enable){ 50 | enableWallhackG = enable; 51 | } 52 | 53 | void SetOutline(bool enable){ 54 | enableWallhackO = enable; 55 | } 56 | 57 | void SetSkyColor(bool enable){ 58 | enableSkyColor = enable; 59 | } 60 | 61 | void SetRainbow(bool enable){ 62 | enableRainbow = enable; 63 | } 64 | 65 | void SetR(int set){ 66 | r = set; 67 | } 68 | 69 | void SetG(int set1){ 70 | g = set1; 71 | } 72 | 73 | void SetB(int set2){ 74 | b = set2; 75 | } 76 | 77 | void SetWireframeWidth(int set3){ 78 | w = set3; 79 | } 80 | 81 | void SetGlowWidth(int set4){ 82 | gw = set4; 83 | } 84 | 85 | void SetOutlineWidth(int set5){ 86 | ow = set5; 87 | } 88 | 89 | bool getWallhackEnabled(){ 90 | return enableWallhack; 91 | } 92 | 93 | bool getWireframeEnabled(){ 94 | return enableWallhackW; 95 | } 96 | 97 | bool getGlowEnabled(){ 98 | return enableWallhackG; 99 | } 100 | 101 | bool getOutlineEnabled(){ 102 | return enableWallhackO; 103 | } 104 | 105 | bool getSkyColorEnabled(){ 106 | return enableSkyColor; 107 | } 108 | 109 | bool getRainbowEnabled(){ 110 | return enableRainbow; 111 | } 112 | 113 | int (*old_glGetUniformLocation)(GLuint, const GLchar *); 114 | GLint new_glGetUniformLocation(GLuint program, const GLchar *name) { 115 | return old_glGetUniformLocation(program, name); 116 | } 117 | 118 | bool isCurrentShader(const char *shader) { 119 | GLint currProgram; 120 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 121 | return old_glGetUniformLocation(currProgram, shader) != -1; 122 | } 123 | 124 | void (*old_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); 125 | void new_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { 126 | old_glDrawElements(mode, count, type, indices); 127 | if (mode != GL_TRIANGLES || count < 1000) return; { 128 | GLint currProgram; 129 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 130 | GLint id = old_glGetUniformLocation(currProgram, getShader()); 131 | if (id == -1) return; 132 | if (getWireframeEnabled()) { 133 | 134 | if (enableWallhackW) { 135 | glDepthRangef(1, 0.5); 136 | } 137 | else { 138 | glDepthRangef(0.5, 1); 139 | } 140 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 141 | glColorMask(1, 1, 1, 1); 142 | glEnable(GL_BLEND); 143 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 144 | glLineWidth(w); 145 | performRGBChange(); 146 | old_glDrawElements(GL_LINE_LOOP, count, type, indices); 147 | if (isRGB) { 148 | glBlendColor(redd*3.92156863*0.001, greenn*3.92156863*0.001, bluee*3.92156863*0.001, 1.000); 149 | } 150 | } 151 | 152 | if (getWallhackEnabled()) { 153 | glDepthRangef(1, 0.5); 154 | performRGBChange(); 155 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 156 | glColorMask(1, 1, 1, 1); 157 | glEnable(GL_BLEND); 158 | glBlendFunc(GL_SRC_ALPHA, GL_ONE); 159 | glBlendEquation(GL_FUNC_ADD); 160 | if (isRGB) { 161 | glBlendColor(redd*3.92156863*0.001, greenn*3.92156863*0.001, bluee*3.92156863*0.001, 1.000); 162 | } 163 | } 164 | 165 | if (getGlowEnabled()) { 166 | glEnable(GL_BLEND); 167 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 168 | glColorMask(1, 1, 1, 1); 169 | glEnable(GL_BLEND); 170 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 171 | glLineWidth(gw); 172 | glDepthRangef(0.5, 1); 173 | performRGBChange(); 174 | old_glDrawElements(GL_LINES, count, type, indices); 175 | glBlendColor(1, 1, 1, 1); 176 | glDepthRangef(1, 0.5); 177 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 178 | if (isRGB) { 179 | glBlendColor(redd*3.92156863*0.001, greenn*3.92156863*0.001, bluee*3.92156863*0.001, 1.000); 180 | } 181 | } 182 | 183 | if (getOutlineEnabled()) { 184 | glDepthRangef(1, 0); 185 | performRGBChange(); 186 | glLineWidth(ow); 187 | glEnable(GL_BLEND); 188 | glColorMask(1, 1, 1, 1); 189 | glEnable(GL_BLEND); 190 | glBlendFunc(GL_SRC_ALPHA, GL_ONE); 191 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 192 | glBlendColor(0, 0, 0, 1); 193 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 194 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 195 | glDepthRangef(1, 0.5); 196 | glBlendColor(GLfloat(float(r)/255), GLfloat(float(g)/255), GLfloat(float(b)/255), 1); 197 | old_glDrawElements(GL_LINES, count, type, indices); 198 | if (isRGB) { 199 | glBlendColor(redd*3.92156863*0.001, greenn*3.92156863*0.001, bluee*3.92156863*0.001, 1.000); 200 | } 201 | } 202 | 203 | if (getSkyColorEnabled()) { 204 | glDepthRangef(1, 0); 205 | performRGBChange(); 206 | glEnable(GL_BLEND); 207 | glColorMask(1, 1, 1, 1); 208 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 209 | glBlendColor(0, 0, 0, 1); 210 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 211 | glDepthRangef(0.5, 1); 212 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 213 | old_glDrawElements(GL_LINES, count, type, indices); 214 | if (isRGB) { 215 | glBlendColor(redd*3.92156863*0.001, greenn*3.92156863*0.001, bluee*3.92156863*0.001, 1.000); 216 | } 217 | } 218 | 219 | if (getRainbowEnabled()) { 220 | if (red == 255){ 221 | if (blue == 0 ){ 222 | if (gren == 255){} else{ 223 | gren = gren+1; 224 | } 225 | } 226 | } 227 | if (gren == 255){ 228 | if (red == 0){} else{ 229 | red = red-1; 230 | } 231 | } 232 | if (gren == 255) { 233 | if (red == 0) { 234 | if (blue==255){} else{ 235 | blue = blue+1; 236 | } 237 | } 238 | } 239 | if (blue == 255) { 240 | if (gren == 0) { 241 | mi = 1; 242 | red = red+1; 243 | } 244 | else{ 245 | gren = gren-1; 246 | } 247 | } 248 | if (mi == 1){ 249 | if (red == 255){ 250 | if (blue == 0){} else{ 251 | blue = blue-1; 252 | } 253 | } 254 | } 255 | SetR(red); 256 | SetG(gren); 257 | SetB(blue); 258 | /*glDepthRangef(1, 0.5); 259 | performRGBChange(); 260 | glEnable(GL_BLEND); 261 | glBlendFunc(GL_SRC_COLOR, GL_CONSTANT_COLOR); 262 | glBlendEquation(GL_FUNC_ADD); 263 | glBlendColor(redd*3.92156863*0.001, greenn*3.92156863*0.001, bluee*3.92156863*0.001, 1.000); 264 | glDepthFunc(GL_ALWAYS); 265 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 266 | glColorMask(redd,greenn, bluee, 255); 267 | glBlendFunc(GL_DST_COLOR, GL_ONE); 268 | glDepthFunc(GL_LESS); 269 | glDepthMask(true); 270 | glDepthMask(false); 271 | glBlendColor(0.0, 0.0, 0.0, 0.0);*/ 272 | } 273 | 274 | old_glDrawElements(mode, count, type, indices); 275 | glDepthRangef(0.5, 1); 276 | glColorMask(1, 1, 1, 1); 277 | glDisable(GL_BLEND); 278 | } 279 | } 280 | 281 | bool mlovinit(){ 282 | handle = NULL; 283 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 284 | if(!handle) { 285 | return false; 286 | } 287 | return true; 288 | } 289 | 290 | void LogShaders(){ 291 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 292 | auto p_glGetUniformLocation = (const void*(*)(...))dlsym(handle, "glGetUniformLocation"); 293 | const char *dlsym_error = dlerror(); 294 | if(dlsym_error) { 295 | return; 296 | } else { 297 | MSHookFunction(reinterpret_cast(p_glGetUniformLocation), reinterpret_cast(new_glGetUniformLocation), reinterpret_cast(&old_glGetUniformLocation)); 298 | } 299 | } 300 | 301 | void Wallhack(){ 302 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 303 | auto p_glDrawElements = (const void*(*)(...))dlsym(handle, "glDrawElements"); 304 | const char *dlsym_error = dlerror(); 305 | if(dlsym_error) { 306 | return; 307 | } else { 308 | MSHookFunction(reinterpret_cast(p_glDrawElements), reinterpret_cast(new_glDrawElements), reinterpret_cast(&old_glDrawElements)); 309 | } 310 | } 311 | 312 | #endif 313 | -------------------------------------------------------------------------------- /Norka_Chams/RGB.h: -------------------------------------------------------------------------------- 1 | int rgb = 1; 2 | bool rF = true, gF, bF = true, rF_, gF_, bF_; 3 | float redd = 255, greenn = 0, bluee = 255; 4 | void performRGBChange() { 5 | switch (rgb) { 6 | case 0: { 7 | if (gF) { 8 | greenn--; 9 | if (!greenn) { gF = !gF; rF_ = !rF_; } 10 | break; } 11 | 12 | if (redd < 255 && rF_) redd++; 13 | else { rgb++; redd = 255; rF = !rF; rF_ = !rF_; } 14 | break; } case 1: { 15 | if (bF) { 16 | bluee--; 17 | if (!bluee) { bF = !bF; gF_ = !gF_; } 18 | break; } 19 | 20 | if (greenn < 255 && gF_) greenn++; 21 | else { rgb++; greenn = 255; gF = !gF; gF_ = !gF_; } 22 | break;} case 2: { 23 | if (rF) { 24 | redd--; 25 | if (!redd) { rF = !rF; bF_ = !bF_; } 26 | break; } 27 | 28 | if (bluee < 255 && bF_) bluee++; 29 | else { rgb = 0; bluee = 255; bF = !bF; bF_ = !bF_; } 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Norka_Chams/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include "Includes/Chams.h" 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | bool chams, wireframe, glow, outline, rainbow = false; 19 | 20 | const char *features[] = { 21 | OBFUSCATE("Text_Visuals"), 22 | OBFUSCATE("ButtonOnOff_Color Chams"), 23 | OBFUSCATE("ButtonOnOff_Wireframe Chams"), 24 | OBFUSCATE("ButtonOnOff_Glow Chams"), 25 | OBFUSCATE("ButtonOnOff_Outline Chams"), 26 | OBFUSCATE("ButtonOnOff_Rainbow Mode"), 27 | OBFUSCATE("Text_Chams Settings"),//6 28 | OBFUSCATE("SeekBar_Color Red_0_255"), 29 | OBFUSCATE("SeekBar_Color Green_0_255"), 30 | OBFUSCATE("SeekBar_Color Blue_0_255"), 31 | OBFUSCATE("SeekBar_Wireframe Width_0_15"), 32 | OBFUSCATE("SeekBar_Glow Width_0_15"), 33 | OBFUSCATE("SeekBar_Outline Width_0_15"), 34 | 35 | switch (feature) { 36 | case 1: 37 | chams = !chams; 38 | if (chams) { 39 | SetWallhack(true); 40 | } else { 41 | SetWallhack(false); 42 | } 43 | break; 44 | case 2: 45 | wireframe = !wireframe; 46 | if (wireframe) { 47 | SetWireframe(true); 48 | } else { 49 | SetWireframe(false); 50 | } 51 | break; 52 | case 3: 53 | glow = !glow; 54 | if (glow) { 55 | SetGlow(true); 56 | } else { 57 | SetGlow(false); 58 | } 59 | break; 60 | case 4: 61 | outline = !outline; 62 | if (outline) { 63 | SetOutline(true); 64 | } else { 65 | SetOutline(false); 66 | } 67 | break; 68 | case 5: 69 | rainbow = !rainbow; 70 | if (rainbow) { 71 | SetRainbow(true); 72 | } else { 73 | SetRainbow(false); 74 | } 75 | break; 76 | case 7: 77 | SetR(value); 78 | break; 79 | case 8: 80 | SetG(value); 81 | break; 82 | case 9: 83 | SetB(value); 84 | break; 85 | case 10: 86 | SetWireframeWidth(value); 87 | break; 88 | case 11: 89 | SetGlowWidth(value); 90 | break; 91 | case 12: 92 | SetOutlineWidth(value); 93 | break; 94 | 95 | void *cheat(void *) { 96 | ProcMap il2cppMap; 97 | do { 98 | il2cppMap = KittyMemory::getLibraryMap(libName); 99 | sleep(10); 100 | } while (!isLibraryLoaded(libName) && mlovinit()); 101 | setShader("_BumpMap"); 102 | LogShaders(); 103 | Wallhack(); 104 | 105 | return NULL; 106 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Collection-Chams-For-libil2cpp-Unity-Games 2 | 3 | These chams are suitable for almost all unity games that have OpenGL ES.Duplicates are possible.In the folders there is an example of how to add chams to your mod menu. Using these examples, you can write your own chams. 4 | 5 | I would be very happy if you subscribe to my telegram channel @ darkrare. 6 | -------------------------------------------------------------------------------- /Rapid_Chams/Chams.h: -------------------------------------------------------------------------------- 1 | #ifndef RAPID_CHAMS 2 | #define RAPID_CHAMS 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | static void *handle; 9 | static const char* shaderName; 10 | static bool enableWallhack; 11 | static bool enableWallhackS; 12 | static bool enableWallhackW; 13 | static bool enableWallhackG; 14 | static bool enableWallhackO; 15 | static bool enableRainbow; 16 | static bool enableRainbow1; 17 | static float r = 255.0f; 18 | static float g = 0.0f; 19 | static float b = 0.0f; 20 | static int w = 1; 21 | static int a = 255; 22 | 23 | float red = 255.0f; 24 | float gren = 0.0f; 25 | float blue =0.0f; 26 | float mi = 0.0f; 27 | 28 | void setShader(const char* s) { 29 | shaderName = s; 30 | } 31 | const char* getShader() { 32 | return shaderName; 33 | } 34 | 35 | void SetWallhack(bool enable){ 36 | enableWallhack = enable; 37 | } 38 | 39 | void SetWallhackS(bool enable){ 40 | enableWallhackS = enable; 41 | } 42 | 43 | void SetWallhackW(bool enable){ 44 | enableWallhackW = enable; 45 | } 46 | 47 | void SetWallhackG(bool enable){ 48 | enableWallhackG = enable; 49 | } 50 | 51 | void SetWallhackO(bool enable){ 52 | enableWallhackO = enable; 53 | } 54 | 55 | 56 | 57 | void SetRainbow(bool enable){ 58 | enableRainbow = enable; 59 | } 60 | void SetRainbow1(bool enable){ 61 | enableRainbow1 = enable; 62 | } 63 | 64 | void SetR(int set){ 65 | r = set; 66 | } 67 | 68 | void SetG(int set){ 69 | g = set; 70 | } 71 | 72 | void SetB(int set){ 73 | b = set; 74 | } 75 | 76 | void SetW(int set){ 77 | w = set; 78 | } 79 | 80 | 81 | bool getWallhackEnabled(){ 82 | return enableWallhack; 83 | } 84 | 85 | bool getShadingEnabled(){ 86 | return enableWallhackS; 87 | } 88 | 89 | bool getWireframeEnabled(){ 90 | return enableWallhackW; 91 | } 92 | 93 | bool getGlowEnabled(){ 94 | return enableWallhackG; 95 | } 96 | 97 | bool getOutlineEnabled(){ 98 | return enableWallhackO; 99 | } 100 | 101 | bool getRainbowEnabled(){ 102 | return enableRainbow; 103 | } 104 | bool getRainbow1Enabled(){ 105 | return enableRainbow1; 106 | } 107 | 108 | int (*old_glGetUniformLocation)(GLuint, const GLchar *); 109 | GLint new_glGetUniformLocation(GLuint program, const GLchar *name) { 110 | return old_glGetUniformLocation(program, name); 111 | } 112 | 113 | bool isCurrentShader(const char *shader) { 114 | GLint currProgram; 115 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 116 | return old_glGetUniformLocation(currProgram, shader) != -1; 117 | } 118 | 119 | void (*old_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void *indices); 120 | void new_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) { 121 | old_glDrawElements(mode, count, type, indices); 122 | if (mode != GL_TRIANGLES || count < 1000) return; 123 | { 124 | GLint currProgram; 125 | glGetIntegerv(GL_CURRENT_PROGRAM, &currProgram); 126 | 127 | GLint id = old_glGetUniformLocation(currProgram, getShader()); 128 | if (id == -1) return; 129 | 130 | if (getWireframeEnabled()) { 131 | 132 | if (enableWallhackW) { 133 | glDepthRangef(1, 0.5); 134 | } 135 | else { 136 | glDepthRangef(0.5, 1); 137 | } 138 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 139 | glColorMask(1, 1, 1, 1); 140 | glEnable(GL_BLEND); 141 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 142 | glLineWidth(w); 143 | old_glDrawElements(GL_LINE_LOOP, count, type, indices); 144 | } 145 | 146 | 147 | if (getWallhackEnabled()) { 148 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), GLfloat(a/255)); 149 | glColorMask(r, g, b, 255); 150 | glEnable(GL_BLEND); 151 | glBlendFunc(GL_CONSTANT_ALPHA, GL_CONSTANT_COLOR); 152 | } 153 | 154 | if (getShadingEnabled()) { 155 | glDepthRangef(1, 0.5); 156 | glEnable(GL_BLEND); 157 | glBlendFunc(GL_SRC_COLOR, GL_CONSTANT_COLOR); 158 | glBlendEquation(GL_FUNC_ADD); 159 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 160 | glDepthFunc(GL_ALWAYS); 161 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 162 | glColorMask(r, g, b, 255); 163 | glBlendFunc(GL_DST_COLOR, GL_ONE); 164 | glDepthFunc(GL_LESS); 165 | glBlendColor(0.0, 0.0, 0.0, 0.0); 166 | } 167 | 168 | if (getGlowEnabled()) { 169 | glEnable(GL_BLEND); 170 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 171 | glColorMask(1, 1, 1, 1); 172 | glEnable(GL_BLEND); 173 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 174 | glLineWidth(w); 175 | 176 | glDepthRangef(0.5, 1); 177 | old_glDrawElements(GL_LINES, count, type, indices); 178 | glBlendColor(1, 1, 1, 1); 179 | glDepthRangef(1, 0.5); 180 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 181 | } 182 | 183 | if (getOutlineEnabled()) { 184 | glDepthRangef(1, 0.5); 185 | glLineWidth(w); 186 | glEnable(GL_BLEND); 187 | glColorMask(1, 1, 1, 1); 188 | glBlendFuncSeparate(GL_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE, GL_ZERO); 189 | glBlendColor(0, 0, 0, 1); 190 | old_glDrawElements(GL_TRIANGLES, count, type, indices); 191 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), 1); 192 | old_glDrawElements(GL_LINES, count, type, indices); 193 | } 194 | 195 | if (getRainbowEnabled()) { 196 | if(getRainbow1Enabled){ 197 | if (red == 255){ 198 | if (blue == 0 ){ 199 | if (gren == 255){} else{ 200 | gren = gren+1; 201 | } 202 | } 203 | } 204 | if (gren == 255){ 205 | if (red == 0){} else{ 206 | red = red-1; 207 | } 208 | } 209 | if (gren == 255) { 210 | if (red == 0) { 211 | if (blue==255){} else{ 212 | blue = blue+1; 213 | } 214 | } 215 | } 216 | if (blue == 255) { 217 | if (gren == 0) { 218 | mi = 1; 219 | red = red+1; 220 | } 221 | else{ 222 | gren = gren-1; 223 | } 224 | } 225 | if (mi == 1){ 226 | if (red == 255){ 227 | if (blue == 0){} else{ 228 | blue = blue-1; 229 | } 230 | } 231 | } 232 | SetR(red); 233 | SetG(gren); 234 | SetB(blue); 235 | } 236 | glBlendColor(GLfloat(r/255), GLfloat(g/255), GLfloat(b/255), GLfloat(a/255)); 237 | glColorMask(1, 1, 1, 1); 238 | glEnable(GL_BLEND); 239 | glBlendFunc(GL_ONE_MINUS_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_ALPHA); 240 | 241 | } 242 | old_glDrawElements(mode, count, type, indices); 243 | 244 | glDepthRangef(0.5, 1); 245 | 246 | glColorMask(1, 1, 1, 1); 247 | glDisable(GL_BLEND); 248 | } 249 | } 250 | 251 | bool mlovinit(){ 252 | handle = NULL; 253 | handle = dlopen("libGLESv2.so", RTLD_LAZY); 254 | if(!handle){ 255 | return false; 256 | } 257 | return true; 258 | } 259 | 260 | void LogShaders(){ 261 | auto p_glGetUniformLocation = (const void*(*)(...))dlsym(handle, "glGetUniformLocation"); 262 | const char *dlsym_error = dlerror(); 263 | if(dlsym_error){ 264 | return; 265 | }else{ 266 | MSHookFunction(reinterpret_cast(p_glGetUniformLocation), reinterpret_cast(new_glGetUniformLocation), reinterpret_cast(&old_glGetUniformLocation)); 267 | } 268 | } 269 | 270 | void Wallhack(){ 271 | auto p_glDrawElements = (const void*(*)(...))dlsym(handle, "glDrawElements"); 272 | const char *dlsym_error = dlerror(); 273 | if(dlsym_error){ 274 | return; 275 | }else{ 276 | MSHookFunction(reinterpret_cast(p_glDrawElements), reinterpret_cast(new_glDrawElements), reinterpret_cast(&old_glDrawElements)); 277 | } 278 | } 279 | 280 | 281 | #endif 282 | 283 | -------------------------------------------------------------------------------- /Rapid_Chams/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "KittyMemory/MemoryPatch.h" 6 | #include 7 | #include 8 | 9 | bool chams, shading, wireframe, glow, outline, rainbow = false; 10 | const char *libName = "libil2cpp.so"; 11 | 12 | const char *features[] = { 13 | "Text_Chams Menu︎", //1 14 | "Button_Default Chams",//2 15 | "Button_Shading Chams", //3 16 | "Button_Wireframe Chams",//4 17 | "Button_Glow Chams",//5 18 | "Button_Outline Chams", //6 19 | "Button_Rainbow Chams", //7 20 | "Button_Bypass Chams", //8 21 | "Seek_Line Width_0_12",//9 22 | "Seek_Color R_0_255",//10 23 | "Seek_Color G_0_255",//11 24 | "Seek_Color B_0_255",//12 25 | 26 | switch (feature) { 27 | case 2: 28 | chams = !chams; 29 | if (chams) { 30 | SetWallhack(true); 31 | } else { 32 | SetWallhack(false); 33 | } 34 | break; 35 | case 3: 36 | shading = !shading; 37 | if (shading) { 38 | SetWallhackS(true); 39 | } else { 40 | SetWallhackS(false); 41 | } 42 | break; 43 | case 4: 44 | wireframe = !wireframe; 45 | if (wireframe) { 46 | SetWallhackW(true); 47 | } else { 48 | SetWallhackW(false); 49 | } 50 | break; 51 | case 5: 52 | glow = !glow; 53 | if (glow) { 54 | SetWallhackG(true); 55 | } else { 56 | SetWallhackG(false); 57 | } 58 | break; 59 | case 6: 60 | outline = !outline; 61 | if (outline) { 62 | SetWallhackO(true); 63 | } else { 64 | SetWallhackO(false); 65 | } 66 | break; 67 | case 7: 68 | rainbow = !rainbow; 69 | if (rainbow) { 70 | SetRainbow(true); 71 | } else { 72 | SetRainbow(false); 73 | } 74 | break; 75 | case 8: 76 | bypass = !bypass; 77 | if (bypass) { 78 | hexPatches.Bypass.Modify(); 79 | } else { 80 | hexPatches.Bypass.Restore(); 81 | } 82 | break; 83 | case 9: 84 | SetW(value); 85 | break; 86 | case 10: 87 | SetR(value); 88 | break; 89 | case 11: 90 | SetG(value); 91 | break; 92 | case 12: 93 | SetB(value); 94 | break; 95 | 96 | void *hack_thread(void *) { 97 | 98 | ProcMap il2cppMap; 99 | do { 100 | il2cppMap = KittyMemory::getLibraryMap(libName); 101 | sleep(1); 102 | } while (!il2cppMap.isValid() && mlovinit()); 103 | setShader("_BumpMap"); 104 | LogShaders(); 105 | Wallhack(); 106 | 107 | hexPatches.Bypass = MemoryPatch::createWithHex("libil2cpp.so", 0xB3FE74,"1E FF 2F E1"); 108 | 109 | return NULL; 110 | } 111 | --------------------------------------------------------------------------------